UPDATE: Dump of initial files

base/src/test/engineering/mod.rs

@@ -0,0 +1,6 @@
+mod test_bessel;
+mod test_bit_operations;
+mod test_complex;
+mod test_convert;
+mod test_misc;
+mod test_number_basis;

base/src/test/engineering/test_bessel.rs

@@ -0,0 +1,53 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_besseli() {
+    let mut model = new_empty_model();
+
+    model._set("B1", "=BESSELI()");
+    model._set("B2", "=BESSELI(1,2, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_besselj() {
+    let mut model = new_empty_model();
+
+    model._set("B1", "=BESSELJ()");
+    model._set("B2", "=BESSELJ(1,2, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_besselk() {
+    let mut model = new_empty_model();
+
+    model._set("B1", "=BESSELK()");
+    model._set("B2", "=BESSELK(1,2, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bessely() {
+    let mut model = new_empty_model();
+
+    model._set("B1", "=BESSELY()");
+    model._set("B2", "=BESSELY(1,2, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}

base/src/test/engineering/test_bit_operations.rs

@@ -0,0 +1,99 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_bitand() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITAND(1,5)");
+    model._set("A2", "=BITAND(13, 25");
+
+    model._set("B1", "=BITAND(1)");
+    model._set("B2", "=BITAND(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "1");
+    assert_eq!(model._get_text("A2"), "9");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bitor() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITOR(1, 5)");
+    model._set("A2", "=BITOR(13, 10");
+
+    model._set("B1", "=BITOR(1)");
+    model._set("B2", "=BITOR(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "5");
+    assert_eq!(model._get_text("A2"), "15");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bitxor() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITXOR(1, 5)");
+    model._set("A2", "=BITXOR(13, 25");
+
+    model._set("B1", "=BITXOR(1)");
+    model._set("B2", "=BITXOR(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "4");
+    assert_eq!(model._get_text("A2"), "20");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bitlshift() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITLSHIFT(4, 2)");
+    model._set("A2", "=BITLSHIFT(13, 7");
+
+    model._set("B1", "=BITLSHIFT(1)");
+    model._set("B2", "=BITLSHIFT(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "16");
+    assert_eq!(model._get_text("A2"), "1664");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bitrshift() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITRSHIFT(4, 2)");
+    model._set("A2", "=BITRSHIFT(13, 7");
+    model._set("A3", "=BITRSHIFT(145, -3");
+
+    model._set("B1", "=BITRSHIFT(1)");
+    model._set("B2", "=BITRSHIFT(1, 2, 3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "1");
+    assert_eq!(model._get_text("A2"), "0");
+    assert_eq!(model._get_text("A3"), "1160");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+// Excel does not pass this test (g sheets does)
+#[test]
+fn fn_bitshift_overflow() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BITRSHIFT(12, -53)");
+    model._set("A2", "=BITLSHIFT(12, 53)");
+    model.evaluate();
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+}

base/src/test/engineering/test_complex.rs

@@ -0,0 +1,162 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_complex() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=COMPLEX(3, 4.5, "i")"#);
+    model._set("A2", r#"=COMPLEX(3, -5)"#);
+    model._set("A3", r#"=COMPLEX(0, 42, "j")"#);
+
+    model._set("B1", "=COMPLEX()");
+    model._set("B2", r#"=COMPLEX(1,2, "i", 1)"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "3+4.5i");
+    assert_eq!(model._get_text("A2"), "3-5i");
+    assert_eq!(model._get_text("A3"), "42j");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_imabs() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMABS("3+4i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "5");
+}
+
+#[test]
+fn fn_imaginary() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMAGINARY("3+4i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "4");
+}
+
+#[test]
+fn fn_imreal() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMREAL("3+4i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "3");
+}
+
+#[test]
+fn fn_imargument() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMARGUMENT("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "0.643501109");
+}
+
+#[test]
+fn fn_imconjugate() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMCONJUGATE("3+4i")"#);
+    model._set("A2", r#"=IMCONJUGATE("12.7-32j")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "3-4i");
+    assert_eq!(model._get_text("A2"), "12.7+32j");
+}
+
+#[test]
+fn fn_imcos() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMCOS("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "-6.58066304055116+7.58155274274654i");
+}
+
+#[test]
+fn fn_imsin() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMSIN("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "-7.61923172032141-6.548120040911i");
+}
+
+#[test]
+fn fn_imaginary_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMAGINARY("3.4i")"#);
+    model._set("A2", r#"=IMAGINARY("-3.4")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "3.4");
+    assert_eq!(model._get_text("A2"), "0");
+}
+
+#[test]
+fn fn_imcosh() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMCOSH("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "-27.0349456030742+3.85115333481178i");
+}
+
+#[test]
+fn fn_imcot() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMCOT("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "0.0049011823943045-0.999266927805902i"
+    );
+}
+
+#[test]
+fn fn_imtan() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=IMTAN("4+3i")"#);
+
+    model.evaluate();
+
+    assert_eq!(
+        model._get_text("A1"),
+        "0.00490825806749608+1.00070953606723i"
+    );
+}
+
+#[test]
+fn fn_power() {
+    let mut model = new_empty_model();
+    model._set("A2", r#"=IMPOWER("4+3i", 3)"#);
+    model._set("A3", r#"=IMABS(IMSUB(IMPOWER("-i", -3), "-1"))<G1"#);
+    model._set("A3", r#"=IMABS(IMSUB(IMPOWER("-1", 0.5), "i"))<G1"#);
+
+    model._set("A1", r#"=IMABS(IMSUB(B1, "-1"))<G1"#);
+    model._set("B1", r#"=IMPOWER("i", 2)"#);
+
+    // small number
+    model._set("G1", "0.0000001");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "TRUE");
+    assert_eq!(model._get_text("A2"), "-44+117i");
+    assert_eq!(model._get_text("A3"), "TRUE");
+    assert_eq!(model._get_text("A3"), "TRUE");
+}

base/src/test/engineering/test_convert.rs

@@ -0,0 +1,35 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_convert() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=CONVERT(1, "lbm", "kg")"#);
+    model._set("A2", r#"=CONVERT(68, "F", "C")"#);
+    model._set("A3", r#"=CONVERT(2.5, "ft", "sec")"#);
+    model._set("A4", r#"=CONVERT(CONVERT(100,"ft","m"),"ft","m""#);
+
+    model._set("B1", "6");
+
+    model._set("A5", r#"=CONVERT(B1,"C","F")"#);
+    model._set("A6", r#"=CONVERT(B1,"tsp","tbs")"#);
+    model._set("A7", r#"=CONVERT(B1,"gal","l")"#);
+    model._set("A8", r#"=CONVERT(B1,"mi","km")"#);
+    model._set("A9", r#"=CONVERT(B1,"km","mi")"#);
+    model._set("A10", r#"=CONVERT(B1,"in","ft")"#);
+    model._set("A11", r#"=CONVERT(B1,"cm","in")"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "0.45359237");
+    assert_eq!(model._get_text("A2"), "19.65");
+    assert_eq!(model._get_text("A3"), "#N/A");
+    assert_eq!(model._get_text("A4"), "9.290304");
+
+    assert_eq!(model._get_text("A5"), "42.8");
+    assert_eq!(model._get_text("A6"), "2");
+    assert_eq!(model._get_text("A7"), "22.712470704"); //22.71741274");
+    assert_eq!(model._get_text("A8"), "9.656064");
+    assert_eq!(model._get_text("A9"), "3.728227153");
+    assert_eq!(model._get_text("A10"), "0.5");
+    assert_eq!(model._get_text("A11"), "2.362204724");
+}

base/src/test/engineering/test_misc.rs

@@ -0,0 +1,66 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_getstep() {
+    let mut model = new_empty_model();
+    model._set("A1", "=GESTEP(7, 4.6)");
+    model._set("A2", "=GESTEP(45, 45)");
+    model._set("A3", "=GESTEP(-7, -6)");
+    model._set("A4", "=GESTEP(0.1)");
+    model._set("A5", "=GESTEP(-0.1)");
+
+    model._set("B1", "=GESTEP()");
+    model._set("B2", "=GESTEP(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1");
+    assert_eq!(model._get_text("A2"), *"1");
+    assert_eq!(model._get_text("A3"), *"0");
+    assert_eq!(model._get_text("A4"), *"1");
+    assert_eq!(model._get_text("A5"), *"0");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_delta() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DELTA(7, 7)");
+    model._set("A2", "=DELTA(-7, -7)");
+    model._set("A3", "=DELTA(-7, 7)");
+    model._set("A4", "=DELTA(5, 0.5)");
+    model._set("A5", "=DELTA(-0, 0)");
+
+    model._set("B1", "=DELTA()");
+    model._set("B2", "=DELTA(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1");
+    assert_eq!(model._get_text("A2"), *"1");
+    assert_eq!(model._get_text("A3"), *"0");
+    assert_eq!(model._get_text("A4"), *"0");
+    assert_eq!(model._get_text("A5"), *"1");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_delta_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=3+1e-16");
+    model._set("A2", "=3");
+    model._set("A3", "=3+1e-15");
+    model._set("B1", "=DELTA(A1, A2)");
+    model._set("B2", "=DELTA(A1, A3)");
+
+    model._set("B1", "1");
+    model._set("B2", "0");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("B1"), *"1");
+}

base/src/test/engineering/test_number_basis.rs

@@ -0,0 +1,345 @@
+use crate::test::util::new_empty_model;
+
+#[test]
+fn fn_bin2dec() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BIN2DEC(1100100)");
+    model._set("A2", "=BIN2DEC(1111111111)");
+
+    model._set("B1", "=BIN2DEC()");
+    model._set("B2", "=BIN2DEC(1,2)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "100");
+    assert_eq!(model._get_text("A2"), "-1");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bin2hex() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BIN2HEX(11111011, 4)");
+    model._set("A2", "=BIN2HEX(1110)");
+    model._set("A3", "=BIN2HEX(1111111111)");
+    model._set("A4", "=BIN2HEX(1100011011)");
+
+    model._set("B1", "=BIN2HEX()");
+    model._set("B2", "=BIN2HEX(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "00FB");
+    assert_eq!(model._get_text("A2"), "E");
+    assert_eq!(model._get_text("A3"), "FFFFFFFFFF");
+    assert_eq!(model._get_text("A4"), "FFFFFFFF1B");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bin2oct() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BIN2OCT(11111011, 4)");
+    model._set("A2", "=BIN2OCT(1110)");
+    model._set("A3", "=BIN2OCT(1111111111)");
+    model._set("A4", "=BIN2OCT(1100011011)");
+
+    model._set("B1", "=BIN2OCT()");
+    model._set("B2", "=BIN2OCT(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "0373");
+    assert_eq!(model._get_text("A2"), "16");
+    assert_eq!(model._get_text("A3"), "7777777777");
+    assert_eq!(model._get_text("A4"), "7777777433");
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_dec2bin() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEC2BIN(9, 4)");
+    model._set("A2", "=DEC2BIN(-100)");
+    model._set("A3", "=DEC2BIN(-1)");
+    model._set("A4", "=DEC2BIN(0, 3)");
+
+    model._set("B1", "=DEC2BIN()");
+    model._set("B2", "=DEC2BIN(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "1001");
+    assert_eq!(model._get_text("A2"), "1110011100");
+    assert_eq!(model._get_text("A3"), "1111111111");
+    assert_eq!(model._get_text("A4"), "000");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_dec2hex() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEC2HEX(100, 4)");
+    model._set("A2", "=DEC2HEX(-54)");
+    model._set("A3", "=DEC2HEX(28)");
+    model._set("A4", "=DEC2HEX(64, 1)");
+
+    model._set("B1", "=DEC2HEX()");
+    model._set("B2", "=DEC2HEX(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "0064");
+    assert_eq!(model._get_text("A2"), "FFFFFFFFCA");
+    assert_eq!(model._get_text("A3"), "1C");
+    assert_eq!(model._get_text("A4"), "#NUM!");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_dec2oct() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEC2OCT(58, 3)");
+    model._set("A2", "=DEC2OCT(-100)");
+
+    model._set("B1", "=DEC2OCT()");
+    model._set("B2", "=DEC2OCT(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "072");
+    assert_eq!(model._get_text("A2"), "7777777634");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_hex2bin() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=HEX2BIN("F", 8)"#);
+    model._set("A2", r#"=HEX2BIN("B7")"#);
+    model._set("A3", r#"=HEX2BIN("FFFFFFFFFF")"#);
+
+    model._set("B1", "=HEX2BIN()");
+    model._set("B2", "=HEX2BIN(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "00001111");
+    assert_eq!(model._get_text("A2"), "10110111");
+    assert_eq!(model._get_text("A3"), "1111111111");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_hex2dec() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=HEX2DEC("A5")"#);
+    model._set("A2", r#"=HEX2DEC("FFFFFFFF5B")"#);
+    model._set("A3", r#"=HEX2DEC("3DA408B9")"#);
+    model._set("A4", r#"=HEX2DEC("FE")"#);
+
+    model._set("B1", "=HEX2DEC()");
+    model._set("B2", "=HHEX2DEC(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "165");
+    assert_eq!(model._get_text("A2"), "-165");
+    assert_eq!(model._get_text("A3"), "1034160313");
+    assert_eq!(model._get_text("A4"), "254");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_hex2oct() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=HEX2OCT("F", 3)"#);
+    model._set("A2", r#"=HEX2OCT("3B4E")"#);
+    model._set("A3", r#"=HEX2OCT("FFFFFFFF00")"#);
+
+    model._set("B1", "=HEX2OCT()");
+    model._set("B2", "=HEX2OCT(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "017");
+    assert_eq!(model._get_text("A2"), "35516");
+    assert_eq!(model._get_text("A3"), "7777777400");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_oct2bin() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=OCT2BIN(3, 3)"#);
+    model._set("A2", r#"=OCT2BIN(7777777000)"#);
+
+    // bounds
+    model._set("G1", r#"=OCT2BIN(777)"#);
+    model._set("G2", r#"=OCT2BIN(778)"#);
+
+    model._set("B1", "=OCT2BIN()");
+    model._set("B2", "=OCT2BIN(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "011");
+    assert_eq!(model._get_text("A2"), "1000000000");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+
+    assert_eq!(model._get_text("G1"), "111111111");
+    assert_eq!(model._get_text("G2"), "#NUM!");
+}
+
+#[test]
+fn fn_oct2dec() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=OCT2DEC(54)"#);
+    model._set("A2", r#"=OCT2DEC(7777777533)"#);
+
+    model._set("B1", "=OCT2DEC()");
+    model._set("B2", "=OCT2DEC(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "44");
+    assert_eq!(model._get_text("A2"), "-165");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_oct2hex() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=OCT2HEX(100, 4)"#);
+    model._set("A2", r#"=OCT2HEX(7777777533)"#);
+
+    model._set("B1", "=OCT2HEX()");
+    model._set("B2", "=OCT2HEX(1,2,3)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), "0040");
+    assert_eq!(model._get_text("A2"), "FFFFFFFF5B");
+
+    assert_eq!(model._get_text("B1"), *"#ERROR!");
+    assert_eq!(model._get_text("B2"), *"#ERROR!");
+}
+
+#[test]
+fn fn_bin2hex_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BIN2HEX(1100011011, -2)");
+    model._set("A2", "=BIN2HEX(1100011011, 11)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+}
+
+#[test]
+fn fn_bin2oct_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=BIN2OCT(1100011011, -2)");
+    model._set("A2", "=BIN2OCT(1100011011, 11)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+}
+
+#[test]
+fn fn_dec2oct_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEC2OCT(-1213, 1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"7777775503");
+}
+
+#[test]
+fn fn_dec2bin_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", "=DEC2BIN(-511, 4)");
+    model._set("A2", "=DEC2BIN(TRUE, -1)");
+    model._set("A3", "=DEC2OCT(TRUE, -1)");
+    model._set("A4", "=DEC2HEX(TRUE, -1)");
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"1000000001");
+    // Note Excel here return #NUM! instead
+    assert_eq!(model._get_text("A2"), *"#VALUE!");
+    assert_eq!(model._get_text("A3"), *"#VALUE!");
+    assert_eq!(model._get_text("A4"), *"#VALUE!");
+}
+
+#[test]
+fn fn_hex2whatever_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=HEX2BIN(TRUE, 4)"#);
+    model._set("A2", r#"=HEX2DEC(TRUE, 4)"#);
+    model._set("A3", r#"=HEX2OCT(TRUE, 4)"#);
+
+    model.evaluate();
+    // Note Excel here return #VALUE! instead
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+    assert_eq!(model._get_text("A3"), *"#NUM!");
+}
+
+#[test]
+fn fn_oct2whatever_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=OCT2BIN(TRUE, 4)"#);
+    model._set("A2", r#"=OCT2DEC(TRUE, 4)"#);
+    model._set("A3", r#"=OCT2HEX(TRUE, 4)"#);
+
+    model.evaluate();
+    // Note Excel here return #VALUE! instead
+    assert_eq!(model._get_text("A1"), *"#NUM!");
+    assert_eq!(model._get_text("A2"), *"#NUM!");
+    assert_eq!(model._get_text("A3"), *"#NUM!");
+}
+
+#[test]
+fn fn_oct2dec_misc() {
+    let mut model = new_empty_model();
+    model._set("A1", r#"=OCT2DEC(777)"#);
+    model._set("A2", r#"=OCT2DEC("777")"#);
+    model._set("A3", r#"=OCT2DEC("-1")"#);
+    model._set("A4", r#"=OCT2BIN("-1")"#);
+    model._set("A5", r#"=OCT2HEX("-1")"#);
+    model._set("A6", r#"=OCT2DEC(4000000000)"#);
+
+    model.evaluate();
+
+    assert_eq!(model._get_text("A1"), *"511");
+    assert_eq!(model._get_text("A1"), *"511");
+
+    assert_eq!(model._get_text("A3"), *"#NUM!");
+    assert_eq!(model._get_text("A4"), *"#NUM!");
+    assert_eq!(model._get_text("A5"), *"#NUM!");
+    assert_eq!(model._get_text("A6"), *"-536870912");
+}