diff --git a/src/PhpSpreadsheet/Calculation/Engineering/ConvertBase.php b/src/PhpSpreadsheet/Calculation/Engineering/ConvertBase.php
index 5122e011..a095690d 100644
--- a/src/PhpSpreadsheet/Calculation/Engineering/ConvertBase.php
+++ b/src/PhpSpreadsheet/Calculation/Engineering/ConvertBase.php
@@ -7,7 +7,7 @@ use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 
 class ConvertBase
 {
-    protected static function validateValue($value, bool $gnumericCheck = false): string
+    protected static function validateValue($value): string
     {
         if (is_bool($value)) {
             if (Functions::getCompatibilityMode() !== Functions::COMPATIBILITY_OPENOFFICE) {
@@ -16,8 +16,10 @@ class ConvertBase
             $value = (int) $value;
         }
 
-        if ($gnumericCheck && Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC) {
-            $value = floor((float) $value);
+        if (is_numeric($value)) {
+            if (Functions::getCompatibilityMode() == Functions::COMPATIBILITY_GNUMERIC) {
+                $value = floor((float) $value);
+            }
         }
 
         return strtoupper((string) $value);
@@ -30,7 +32,7 @@ class ConvertBase
         }
 
         if (is_numeric($places)) {
-            if ($places < 0) {
+            if ($places < 0 || $places > 10) {
                 throw new Exception(Functions::NAN());
             }
 
diff --git a/src/PhpSpreadsheet/Calculation/Engineering/ConvertBinary.php b/src/PhpSpreadsheet/Calculation/Engineering/ConvertBinary.php
index 57f9fc41..ff4873ac 100644
--- a/src/PhpSpreadsheet/Calculation/Engineering/ConvertBinary.php
+++ b/src/PhpSpreadsheet/Calculation/Engineering/ConvertBinary.php
@@ -25,7 +25,7 @@ class ConvertBinary extends ConvertBase
     public static function toDecimal($value): string
     {
         try {
-            $value = self::validateValue(Functions::flattenSingleValue($value), true);
+            $value = self::validateValue(Functions::flattenSingleValue($value));
             $value = self::validateBinary($value);
         } catch (Exception $e) {
             return $e->getMessage();
@@ -65,7 +65,7 @@ class ConvertBinary extends ConvertBase
     public static function toHex($value, $places = null): string
     {
         try {
-            $value = self::validateValue(Functions::flattenSingleValue($value), true);
+            $value = self::validateValue(Functions::flattenSingleValue($value));
             $value = self::validateBinary($value);
             $places = self::validatePlaces(Functions::flattenSingleValue($places));
         } catch (Exception $e) {
@@ -73,8 +73,11 @@ class ConvertBinary extends ConvertBase
         }
 
         if (strlen($value) == 10) {
-            //    Two's Complement
-            return str_repeat('F', 8) . substr(strtoupper(dechex((int) bindec(substr($value, -9)))), -2);
+            $high2 = substr($value, 0, 2);
+            $low8 = substr($value, 2);
+            $xarr = ['00' => '00000000', '01' => '00000001', '10' => 'FFFFFFFE', '11' => 'FFFFFFFF'];
+
+            return $xarr[$high2] . strtoupper(substr('0' . dechex((int) bindec($low8)), -2));
         }
         $hexVal = (string) strtoupper(dechex((int) bindec($value)));
 
@@ -105,16 +108,15 @@ class ConvertBinary extends ConvertBase
     public static function toOctal($value, $places = null): string
     {
         try {
-            $value = self::validateValue(Functions::flattenSingleValue($value), true);
+            $value = self::validateValue(Functions::flattenSingleValue($value));
             $value = self::validateBinary($value);
             $places = self::validatePlaces(Functions::flattenSingleValue($places));
         } catch (Exception $e) {
             return $e->getMessage();
         }
 
-        if (strlen($value) == 10) {
-            //    Two's Complement
-            return str_repeat('7', 7) . substr(strtoupper(decoct((int) bindec(substr($value, -9)))), -3);
+        if (strlen($value) == 10 && substr($value, 0, 1) === '1') { //    Two's Complement
+            return str_repeat('7', 6) . strtoupper(decoct((int) bindec("11$value")));
         }
         $octVal = (string) decoct((int) bindec($value));
 
diff --git a/src/PhpSpreadsheet/Calculation/Engineering/ConvertDecimal.php b/src/PhpSpreadsheet/Calculation/Engineering/ConvertDecimal.php
index bd249633..a34332fb 100644
--- a/src/PhpSpreadsheet/Calculation/Engineering/ConvertDecimal.php
+++ b/src/PhpSpreadsheet/Calculation/Engineering/ConvertDecimal.php
@@ -7,6 +7,13 @@ use PhpOffice\PhpSpreadsheet\Calculation\Functions;
 
 class ConvertDecimal extends ConvertBase
 {
+    const LARGEST_OCTAL_IN_DECIMAL = 536870911;
+    const SMALLEST_OCTAL_IN_DECIMAL = -536870912;
+    const LARGEST_BINARY_IN_DECIMAL = 511;
+    const SMALLEST_BINARY_IN_DECIMAL = -512;
+    const LARGEST_HEX_IN_DECIMAL = 549755813887;
+    const SMALLEST_HEX_IN_DECIMAL = -549755813888;
+
     /**
      * toBinary.
      *
@@ -43,16 +50,13 @@ class ConvertDecimal extends ConvertBase
         }
 
         $value = (int) floor((float) $value);
-        if ($value < -512 || $value > 511) {
+        if ($value > self::LARGEST_BINARY_IN_DECIMAL || $value < self::SMALLEST_BINARY_IN_DECIMAL) {
             return Functions::NAN();
         }
 
         $r = decbin($value);
         // Two's Complement
         $r = substr($r, -10);
-        if (strlen($r) >= 11) {
-            return Functions::NAN();
-        }
 
         return self::nbrConversionFormat($r, $places);
     }
@@ -92,16 +96,37 @@ class ConvertDecimal extends ConvertBase
             return $e->getMessage();
         }
 
-        $value = (int) floor((float) $value);
-        $r = strtoupper(dechex($value));
-        if (strlen($r) == 8) {
-            //    Two's Complement
-            $r = 'FF' . $r;
+        $value = floor((float) $value);
+        if ($value > self::LARGEST_HEX_IN_DECIMAL || $value < self::SMALLEST_HEX_IN_DECIMAL) {
+            return Functions::NAN();
         }
+        $r = strtoupper(dechex((int) $value));
+        $r = self::hex32bit($value, $r);
 
         return self::nbrConversionFormat($r, $places);
     }
 
+    public static function hex32bit(float $value, string $hexstr, bool $force = false): string
+    {
+        if (PHP_INT_SIZE === 4 || $force) {
+            if ($value >= 2 ** 32) {
+                $quotient = (int) ($value / (2 ** 32));
+
+                return strtoupper(substr('0' . dechex($quotient), -2) . $hexstr);
+            }
+            if ($value < -(2 ** 32)) {
+                $quotient = 256 - (int) ceil((-$value) / (2 ** 32));
+
+                return strtoupper(substr('0' . dechex($quotient), -2) . substr("00000000$hexstr", -8));
+            }
+            if ($value < 0) {
+                return "FF$hexstr";
+            }
+        }
+
+        return $hexstr;
+    }
+
     /**
      * toOctal.
      *
@@ -138,11 +163,11 @@ class ConvertDecimal extends ConvertBase
         }
 
         $value = (int) floor((float) $value);
-        $r = decoct($value);
-        if (strlen($r) == 11) {
-            //    Two's Complement
-            $r = substr($r, -10);
+        if ($value > self::LARGEST_OCTAL_IN_DECIMAL || $value < self::SMALLEST_OCTAL_IN_DECIMAL) {
+            return Functions::NAN();
         }
+        $r = decoct($value);
+        $r = substr($r, -10);
 
         return self::nbrConversionFormat($r, $places);
     }
diff --git a/src/PhpSpreadsheet/Calculation/Engineering/ConvertHex.php b/src/PhpSpreadsheet/Calculation/Engineering/ConvertHex.php
index 9147bf08..cbf155ed 100644
--- a/src/PhpSpreadsheet/Calculation/Engineering/ConvertHex.php
+++ b/src/PhpSpreadsheet/Calculation/Engineering/ConvertHex.php
@@ -42,7 +42,9 @@ class ConvertHex extends ConvertBase
             return $e->getMessage();
         }
 
-        return ConvertDecimal::toBinary(self::toDecimal($value), $places);
+        $dec = self::toDecimal($value);
+
+        return ConvertDecimal::toBinary($dec, $places);
     }
 
     /**
@@ -129,9 +131,6 @@ class ConvertHex extends ConvertBase
         }
 
         $decimal = self::toDecimal($value);
-        if ($decimal < -536870912 || $decimal > 536870911) {
-            return Functions::NAN();
-        }
 
         return ConvertDecimal::toOctal($decimal, $places);
     }
diff --git a/src/PhpSpreadsheet/Calculation/Engineering/ConvertOctal.php b/src/PhpSpreadsheet/Calculation/Engineering/ConvertOctal.php
index 1e8823ad..872f0b70 100644
--- a/src/PhpSpreadsheet/Calculation/Engineering/ConvertOctal.php
+++ b/src/PhpSpreadsheet/Calculation/Engineering/ConvertOctal.php
@@ -127,14 +127,16 @@ class ConvertOctal extends ConvertBase
             return $e->getMessage();
         }
 
-        $hexVal = strtoupper(dechex((int) self::toDecimal((int) $value)));
+        $hexVal = strtoupper(dechex((int) self::toDecimal($value)));
+        $hexVal = (PHP_INT_SIZE === 4 && strlen($value) === 10 && $value[0] >= '4') ? "FF$hexVal" : $hexVal;
 
         return self::nbrConversionFormat($hexVal, $places);
     }
 
     protected static function validateOctal(string $value): string
     {
-        if (strlen($value) > preg_match_all('/[01234567]/', $value)) {
+        $numDigits = (int) preg_match_all('/[01234567]/', $value);
+        if (strlen($value) > $numDigits || $numDigits > 10) {
             throw new Exception(Functions::NAN());
         }
 
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php
index faba3de8..bcefa891 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2DecTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Bin2DecTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerBIN2DEC
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testBIN2DEC($expectedResult, ...$args): void
+    public function testBin2Dec($expectedResult, $formula): void
     {
-        $result = Engineering::BINTODEC(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Bin2DecTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/BIN2DEC.php';
     }
+
+    /**
+     * @dataProvider providerBIN2DEC
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testBIN2DECOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testBIN2DECFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=BIN2DEC(101.1)');
+        self::assertEquals(5, $sheet->getCell($cell)->getCalculatedValue(), 'Gnumeric');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=BIN2DEC(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue(), 'Ods');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=BIN2DEC(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php
index 2a16d5ac..2cbea34a 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2HexTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Bin2HexTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerBIN2HEX
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testBIN2HEX($expectedResult, ...$args): void
+    public function testBin2Hex($expectedResult, $formula): void
     {
-        $result = Engineering::BINTOHEX(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Bin2HexTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/BIN2HEX.php';
     }
+
+    /**
+     * @dataProvider providerBIN2HEX
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testBIN2HEXOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testBIN2HEXFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=BIN2HEX(101.1)');
+        self::assertEquals(5, $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=BIN2HEX(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=BIN2HEX(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php
index 78db6a6e..e76778f2 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Bin2OctTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Bin2OctTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerBIN2OCT
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testBIN2OCT($expectedResult, ...$args): void
+    public function testBin2Oct($expectedResult, $formula): void
     {
-        $result = Engineering::BINTOOCT(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Bin2OctTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/BIN2OCT.php';
     }
+
+    /**
+     * @dataProvider providerBIN2OCT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testBIN2OCTOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=BIN2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testBIN2OCTFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=BIN2OCT(101.1)');
+        self::assertEquals(5, $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=BIN2OCT(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=BIN2OCT(101.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php
index 3626ac6b..420af2c5 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2BinTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Dec2BinTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerDEC2BIN
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testDEC2BIN($expectedResult, ...$args): void
+    public function testDEC2BIN($expectedResult, $formula): void
     {
-        $result = Engineering::DECTOBIN(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 5);
+        $sheet->getCell('A1')->setValue("=DEC2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Dec2BinTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/DEC2BIN.php';
     }
+
+    /**
+     * @dataProvider providerDEC2BIN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testDEC2BINOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 5);
+        $sheet->getCell('A1')->setValue("=DEC2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testDEC2BINFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=DEC2BIN(5.1)');
+        self::assertEquals(101, $sheet->getCell($cell)->getCalculatedValue(), 'Gnumeric');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=DEC2BIN(5.1)');
+        self::assertEquals(101, $sheet->getCell($cell)->getCalculatedValue(), 'Ods');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=DEC2BIN(5.1)');
+        self::assertEquals(101, $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php
index d191f620..fcd9c52a 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2HexTest.php
@@ -3,24 +3,41 @@
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
 use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Dec2HexTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerDEC2HEX
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testDEC2HEX($expectedResult, ...$args): void
+    public function testDEC2HEX($expectedResult, $formula): void
     {
-        $result = Engineering::DECTOHEX(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 17);
+        $sheet->getCell('A1')->setValue("=DEC2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +45,54 @@ class Dec2HexTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/DEC2HEX.php';
     }
+
+    /**
+     * @dataProvider providerDEC2HEX
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testDEC2HEXOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 17);
+        $sheet->getCell('A1')->setValue("=DEC2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testDEC2HEXFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=DEC2HEX(17.1)');
+        self::assertEquals(11, $sheet->getCell($cell)->getCalculatedValue(), 'Gnumeric');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=DEC2HEX(17.1)');
+        self::assertEquals(11, $sheet->getCell($cell)->getCalculatedValue(), 'Ods');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=DEC2HEX(17.1)');
+        self::assertEquals(11, $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
+
+    public function test32bitHex(): void
+    {
+        self::assertEquals('A2DE246000', Engineering\ConvertDecimal::hex32bit(-400000000000, 'DE246000', true));
+        self::assertEquals('7FFFFFFFFF', Engineering\ConvertDecimal::hex32bit(549755813887, 'FFFFFFFF', true));
+        self::assertEquals('FFFFFFFFFF', Engineering\ConvertDecimal::hex32bit(-1, 'FFFFFFFF', true));
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php
index 61eb3dbb..19846a3b 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Dec2OctTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Dec2OctTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerDEC2OCT
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testDEC2OCT($expectedResult, ...$args): void
+    public function testDEC2OCT($expectedResult, $formula): void
     {
-        $result = Engineering::DECTOOCT(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 17);
+        $sheet->getCell('A1')->setValue("=DEC2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Dec2OctTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/DEC2OCT.php';
     }
+
+    /**
+     * @dataProvider providerDEC2OCT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testDEC2OCTOds($expectedResult, $formula): void
+    {
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 17);
+        $sheet->getCell('A1')->setValue("=DEC2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testDEC2OCTFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=DEC2OCT(17.1)');
+        self::assertEquals(21, $sheet->getCell($cell)->getCalculatedValue(), 'Gnumeric');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=DEC2OCT(17.1)');
+        self::assertEquals(21, $sheet->getCell($cell)->getCalculatedValue(), 'Ods');
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=DEC2OCT(17.1)');
+        self::assertEquals(21, $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php
index 44d8908d..45973004 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2BinTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Hex2BinTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerHEX2BIN
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testHEX2BIN($expectedResult, ...$args): void
+    public function testHEX2BIN($expectedResult, $formula): void
     {
-        $result = Engineering::HEXTOBIN(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,50 @@ class Hex2BinTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/HEX2BIN.php';
     }
+
+    /**
+     * @dataProvider providerHEX2BIN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testHEX2BINOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testHEX2BINFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=HEX2BIN(10.1)');
+        self::assertEquals('10000', $sheet->getCell($cell)->getCalculatedValue());
+        $cell = 'F21';
+        $sheet->setCellValue($cell, '=HEX2BIN("A.1")');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=HEX2BIN(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=HEX2BIN(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php
index b388b2b7..264ec3e3 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2DecTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Hex2DecTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerHEX2DEC
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testHEX2DEC($expectedResult, ...$args): void
+    public function testHEX2DEC($expectedResult, $formula): void
     {
-        $result = Engineering::HEXTODEC(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,50 @@ class Hex2DecTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/HEX2DEC.php';
     }
+
+    /**
+     * @dataProvider providerHEX2DEC
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testHEX2DECOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testHEX2DECFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=HEX2DEC(10.1)');
+        self::assertEquals(16, $sheet->getCell($cell)->getCalculatedValue());
+        $cell = 'F21';
+        $sheet->setCellValue($cell, '=HEX2DEC("A.1")');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=HEX2DEC(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=HEX2DEC(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php
index bc0a5cb7..15220178 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Hex2OctTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Hex2OctTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerHEX2OCT
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testHEX2OCT($expectedResult, ...$args): void
+    public function testHEX2OCT($expectedResult, $formula): void
     {
-        $result = Engineering::HEXTOOCT(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Hex2OctTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/HEX2OCT.php';
     }
+
+    /**
+     * @dataProvider providerHEX2OCT
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testHEX2OCTOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 'B');
+        $sheet->getCell('A1')->setValue("=HEX2OCT($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testHEX2OCTFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=HEX2OCT(10.1)');
+        self::assertEquals(20, $sheet->getCell($cell)->getCalculatedValue());
+        $cell = 'F21';
+        $sheet->setCellValue($cell, '=HEX2OCT("A.1")');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=HEX2OCT(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=HEX2OCT(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue(), 'Excel');
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/MovedFunctionsTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/MovedFunctionsTest.php
new file mode 100644
index 00000000..04ebb131
--- /dev/null
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/MovedFunctionsTest.php
@@ -0,0 +1,31 @@
+<?php
+
+namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
+
+use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PHPUnit\Framework\TestCase;
+
+// Sanity tests for functions which have been moved out of Engineering
+// to their own classes. A deprecated version remains in Engineering;
+// this class contains cursory tests to ensure that those work properly.
+// If Scrutinizer fails the PR because of these deprecations, I will
+// remove this class from the PR.
+
+class MovedFunctionsTest extends TestCase
+{
+    public function testMovedFunctions(): void
+    {
+        self::assertEquals(178, Engineering::BINTODEC(10110010));
+        self::assertEquals('B2', Engineering::BINTOHEX(10110010));
+        self::assertEquals(144, Engineering::BINTOOCT(1100100));
+        self::assertEquals(101100101, Engineering::DECTOBIN(357));
+        self::assertEquals(165, Engineering::DECTOHEX(357));
+        self::assertEquals(545, Engineering::DECTOOCT(357));
+        self::assertEquals(1100100, Engineering::HEXTOBIN(64));
+        self::assertEquals(357, Engineering::HEXTODEC(165));
+        self::assertEquals(653, Engineering::HEXTOOCT('01AB'));
+        self::assertEquals(1100100, Engineering::OCTTOBIN(144));
+        self::assertEquals(357, Engineering::OCTTODEC(545));
+        self::assertEquals('1AB', Engineering::OCTTOHEX(653));
+    }
+}
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php
index e56c8652..6e60a17b 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2BinTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Oct2BinTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerOCT2BIN
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testOCT2BIN($expectedResult, ...$args): void
+    public function testOCT2BIN($expectedResult, $formula): void
     {
-        $result = Engineering::OCTTOBIN(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Oct2BinTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/OCT2BIN.php';
     }
+
+    /**
+     * @dataProvider providerOCT2BIN
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testOCT2BINOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2BIN($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testOCT2BINFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=HEX2BIN(10.1)');
+        self::assertEquals('10000', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=OCT2BIN(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=OCT2BIN(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php
index 87e213ef..b0537289 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2DecTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Oct2DecTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerOCT2DEC
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testOCT2DEC($expectedResult, ...$args): void
+    public function testOCT2DEC($expectedResult, $formula): void
     {
-        $result = Engineering::OCTTODEC(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Oct2DecTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/OCT2DEC.php';
     }
+
+    /**
+     * @dataProvider providerOCT2DEC
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testOCT2DECOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2DEC($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testOCT2DECFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=OCT2DEC(10.1)');
+        self::assertEquals(8, $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=OCT2DEC(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=OCT2DEC(10.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php
index e2d75a78..05703cc9 100644
--- a/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php
+++ b/tests/PhpSpreadsheetTests/Calculation/Functions/Engineering/Oct2HexTest.php
@@ -2,25 +2,41 @@
 
 namespace PhpOffice\PhpSpreadsheetTests\Calculation\Functions\Engineering;
 
-use PhpOffice\PhpSpreadsheet\Calculation\Engineering;
+use PhpOffice\PhpSpreadsheet\Calculation\Exception as CalcExp;
 use PhpOffice\PhpSpreadsheet\Calculation\Functions;
+use PhpOffice\PhpSpreadsheet\Spreadsheet;
 use PHPUnit\Framework\TestCase;
 
 class Oct2HexTest extends TestCase
 {
+    private $compatibilityMode;
+
     protected function setUp(): void
     {
-        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $this->compatibilityMode = Functions::getCompatibilityMode();
+    }
+
+    protected function tearDown(): void
+    {
+        Functions::setCompatibilityMode($this->compatibilityMode);
     }
 
     /**
      * @dataProvider providerOCT2HEX
      *
      * @param mixed $expectedResult
+     * @param mixed $formula
      */
-    public function testOCT2HEX($expectedResult, ...$args): void
+    public function testOCT2HEX($expectedResult, $formula): void
     {
-        $result = Engineering::OCTTOHEX(...$args);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
         self::assertEquals($expectedResult, $result);
     }
 
@@ -28,4 +44,47 @@ class Oct2HexTest extends TestCase
     {
         return require 'tests/data/Calculation/Engineering/OCT2HEX.php';
     }
+
+    /**
+     * @dataProvider providerOCT2HEX
+     *
+     * @param mixed $expectedResult
+     * @param mixed $formula
+     */
+    public function testOCT2HEXOds($expectedResult, $formula): void
+    {
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        if ($expectedResult === 'exception') {
+            $this->expectException(CalcExp::class);
+        }
+        if ($formula === 'true') {
+            $expectedResult = 1;
+        } elseif ($formula === 'false') {
+            $expectedResult = 0;
+        }
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        $sheet->setCellValue('A2', 101);
+        $sheet->getCell('A1')->setValue("=OCT2HEX($formula)");
+        $result = $sheet->getCell('A1')->getCalculatedValue();
+        self::assertEquals($expectedResult, $result);
+    }
+
+    public function testOCT2HEXFrac(): void
+    {
+        $spreadsheet = new Spreadsheet();
+        $sheet = $spreadsheet->getActiveSheet();
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_GNUMERIC);
+        $cell = 'G1';
+        $sheet->setCellValue($cell, '=OCT2HEX(20.1)');
+        self::assertEquals(10, $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_OPENOFFICE);
+        $cell = 'O1';
+        $sheet->setCellValue($cell, '=OCT2HEX(20.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+        Functions::setCompatibilityMode(Functions::COMPATIBILITY_EXCEL);
+        $cell = 'E1';
+        $sheet->setCellValue($cell, '=OCT2HEX(20.1)');
+        self::assertEquals('#NUM!', $sheet->getCell($cell)->getCalculatedValue());
+    }
 }
diff --git a/tests/data/Calculation/Engineering/BIN2DEC.php b/tests/data/Calculation/Engineering/BIN2DEC.php
index ce9b6d34..4722d8e7 100644
--- a/tests/data/Calculation/Engineering/BIN2DEC.php
+++ b/tests/data/Calculation/Engineering/BIN2DEC.php
@@ -1,49 +1,26 @@
 <?php
 
 return [
-    [
-        '178',
-        '10110010',
-    ],
-    [
-        '100',
-        '1100100',
-    ],
-    // Too large
-    [
-        '#NUM!',
-        '111001010101',
-    ],
-    [
-        '5',
-        '101',
-    ],
-    [
-        '2',
-        '10',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    // Invalid binary number
-    [
-        '#NUM!',
-        '21',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        '-107',
-        '1110010101',
-    ],
-    // 2's Complement
-    [
-        '-1',
-        '1111111111',
-    ],
+    ['178', '10110010'],
+    ['100', '1100100'],
+    ['#NUM!', '111001010101'], // Too large
+    ['5', '101'],
+    ['2', '10'],
+    ['0', '0'],
+    ['#NUM!', '21'], // Invalid binary number
+    ['#VALUE!', 'true'], // Boolean okay for ODS, not for Excel/Gnumeric
+    ['#VALUE!', 'false'], // Boolean okay for ODS, not for Excel/Gnumeric
+    ['-107', '1110010101'], // 2's Complement
+    ['-1', '1111111111'], // 2's Complement
+    ['-512', '1000000000'], // lowest negative
+    ['511', '111111111'], // highest positive
+    ['0', '0000000000'],
+    ['1', '000000001'],
+    ['256', '0100000000'],
+    ['256', '100000000'],
+    ['-256', '1100000000'],
+    [5, 'A2'],
+    ['#NUM!', '"A2"'],
+    [0, 'A3'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/BIN2HEX.php b/tests/data/Calculation/Engineering/BIN2HEX.php
index e88fb3fa..26bbbdc1 100644
--- a/tests/data/Calculation/Engineering/BIN2HEX.php
+++ b/tests/data/Calculation/Engineering/BIN2HEX.php
@@ -1,73 +1,36 @@
 <?php
 
 return [
-    [
-        'B2',
-        '10110010',
-    ],
-    // Too large
-    [
-        '#NUM!',
-        '111001010101',
-    ],
-    // Leading places
-    [
-        '00FB',
-        '11111011',
-        4,
-    ],
-    // Leading places as a float
-    [
-        '0FB',
-        '11111011',
-        3.75,
-    ],
-    // Leading places negative
-    [
-        '#NUM!',
-        '11111011',
-        -1,
-    ],
-    // Leading places non-numeric
-    [
-        '#VALUE!',
-        '11111011',
-        'ABC',
-    ],
-    [
-        'E',
-        '1110',
-    ],
-    [
-        '5',
-        '101',
-    ],
-    [
-        '2',
-        '10',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    // Invalid binary number
-    [
-        '#NUM!',
-        '21',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        'FFFFFFFF95',
-        '1110010101',
-    ],
-    // 2's Complement
-    [
-        'FFFFFFFFFF',
-        '1111111111',
-    ],
+    ['B2', '10110010'],
+    ['#NUM!', '111001010101'], // Too large
+    ['00FB', '11111011, 4'], // Leading places
+    ['0FB', '11111011, 3.75'], // Leading places as a float
+    ['#NUM!', '11111011, -1'], // Leading places negative
+    ['#VALUE!', '11111011, "ABC"'], // Leading places non-numeric
+    ['E', '"1110"'],
+    ['5', '101'],
+    ['2', '10'],
+    ['0', '0'],
+    ['#NUM!', '21'], // Invalid binary number
+    ['#VALUE!', 'true'], // ODS accepts Boolean, Excel/Gnumeric don't
+    ['#VALUE!', 'false'], // ODS accepts Boolean, Excel/Gnumeric don't
+    ['FFFFFFFF95', '1110010101'], // 2's Complement
+    ['FFFFFFFFFF', '1111111111'], // 2's Complement
+    ['FFFFFFFE00', '1000000000'], // lowest negative
+    ['1FF', '111111111'], // highest positive
+    ['0', '0000000000'],
+    ['1', '000000001'],
+    ['100', '0100000000'],
+    ['100', '100000000'],
+    ['FFFFFFFF00', '1100000000'],
+    ['0003', '11, 4'],
+    ['#NUM!', '11, 0'],
+    ['#NUM!', '11, -1'],
+    ['#NUM!', '11, 14'],
+    ['#NUM!', '10001, 1'],
+    ['11', '10001, 2'],
+    [5, 'A2'],
+    ['#NUM!', '"A2"'],
+    [0, 'A3'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/BIN2OCT.php b/tests/data/Calculation/Engineering/BIN2OCT.php
index dd1e4ccb..09265611 100644
--- a/tests/data/Calculation/Engineering/BIN2OCT.php
+++ b/tests/data/Calculation/Engineering/BIN2OCT.php
@@ -1,77 +1,37 @@
 <?php
 
 return [
-    [
-        '144',
-        '1100100',
-    ],
-    [
-        '262',
-        '10110010',
-    ],
-    // Too large
-    [
-        '#NUM!',
-        '111001010101',
-    ],
-    // Leading places
-    [
-        '011',
-        '1001',
-        3,
-    ],
-    // Leading places as a float
-    [
-        '0011',
-        '1001',
-        4.75,
-    ],
-    // Leading places negative
-    [
-        '#NUM!',
-        '1001',
-        -1,
-    ],
-    // Leading places non-numeric
-    [
-        '#VALUE!',
-        '1001',
-        'ABC',
-    ],
-    [
-        '2',
-        '00000010',
-    ],
-    [
-        '5',
-        '00000101',
-    ],
-    [
-        '15',
-        '00001101',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    // Invalid binary number
-    [
-        '#NUM!',
-        '21',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        '7777777625',
-        '1110010101',
-    ],
-    // 2's Complement
-    [
-        '7777777777',
-        '1111111111',
-    ],
+    ['144', 1100100],
+    ['262', '10110010'],
+    ['#NUM!', '111001010101'], // Too large
+    ['011', '1001, 3'], // Leading places
+    ['0011', '1001, 4.75'], // Leading places as a float
+    ['#NUM!', '1001, -1'], // Leading places negative
+    ['#VALUE!', '1001, "ABC"'], // Leading places non-numeric
+    ['2', '00000010'],
+    ['5', '00000101'],
+    ['15', '00001101'],
+    ['0', '0'],
+    ['#NUM!', '21'], // Invalid binary number
+    ['#VALUE!', 'true'], // Boolean okay for ODS, not for others
+    ['#VALUE!', 'false'], // Boolean okay for ODS, not for others
+    ['7777777625', '1110010101'], // 2's Complement
+    ['7777777777', '1111111111'], // 2's Complement
+    ['7777777000', '1000000000'], // lowest negative
+    ['777', '111111111'], // highest positive
+    ['0', '0000000000'],
+    ['1', '000000001'],
+    ['400', '0100000000'],
+    ['400', '100000000'],
+    ['7777777400', '1100000000'],
+    ['0003', '11, 4'],
+    ['#NUM!', '11, 0'],
+    ['#NUM!', '11, -1'],
+    ['#NUM!', '11, 14'],
+    ['#NUM!', '10001, 1'],
+    ['21', '10001, 2'],
+    [5, 'A2'],
+    ['#NUM!', '"A2"'],
+    [0, 'A3'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/DEC2BIN.php b/tests/data/Calculation/Engineering/DEC2BIN.php
index a88b69a8..317c9b5b 100644
--- a/tests/data/Calculation/Engineering/DEC2BIN.php
+++ b/tests/data/Calculation/Engineering/DEC2BIN.php
@@ -1,91 +1,36 @@
 <?php
 
 return [
-    [
-        '101100101',
-        357,
-    ],
-    // Too large
-    [
-        '#NUM!',
-        512,
-    ],
-    // Too small
-    [
-        '#NUM!',
-        -513,
-    ],
-    [
-        '1001',
-        9,
-        4,
-    ],
-    [
-        '00001001',
-        9,
-        8,
-    ],
-    // Leading places as a float
-    [
-        '001001',
-        9,
-        6.75,
-    ],
-    // Leading places negative
-    [
-        '#NUM!',
-        9,
-        -1,
-    ],
-    // Leading places non-numeric
-    [
-        '#VALUE!',
-        9,
-        'ABC',
-    ],
-    [
-        '11110110',
-        246,
-    ],
-    [
-        '#NUM!',
-        12345,
-    ],
-    [
-        '#NUM!',
-        123456789,
-    ],
-    [
-        '1111011',
-        123.45,
-    ],
-    [
-        '0',
-        0,
-    ],
-    // Invalid decimal
-    [
-        '#VALUE!',
-        '3579A',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        '1110011100',
-        -100,
-    ],
-    // 2's Complement
-    [
-        '1110010101',
-        -107,
-    ],
-    // 2's Complement
-    [
-        '1000000000',
-        -512,
-    ],
+    ['101100101', '357'],
+    ['#NUM!', '512'], // Too large
+    ['#NUM!', '-513'], // Too small
+    ['1001', '9, 4'],
+    ['00001001', '9, 8'],
+    ['001001', '9, 6.75'], // Leading places as a float
+    ['#NUM!', '9, -1'], // Leading places negative
+    ['#VALUE!', '9, "ABC"'], // Leading places non-numeric
+    ['11110110', '"246"'],
+    ['#NUM!', '12345'],
+    ['#NUM!', '123456789'],
+    ['1111011', '123.45'],
+    ['0', '0'],
+    ['#VALUE!', '"3579A"'], // Invalid decimal
+    ['#VALUE!', 'true'], // ODS accepts boolean, Excel/Gnumeric don't
+    ['#VALUE!', 'false'], // ODS accepts boolean, Excel/Gnumeric don't
+    ['1110011100', '-100'], // 2's Complement
+    ['1110010101', '-107'], // 2's Complement
+    ['1000000000', '-512'], // lowest negative
+    ['111111111', '511'], // highest positive
+    ['#NUM!', '-513'],
+    ['#NUM!', '512'],
+    ['0011', '3, 4'],
+    ['#NUM!', '3, 0'],
+    ['#NUM!', '3, -1'],
+    ['#NUM!', '3, 14'],
+    ['#NUM!', '3, 1'],
+    ['11', '3, 2'],
+    [101, 'A2'],
+    ['#VALUE!', '"A2"'],
+    [0, 'A3'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/DEC2HEX.php b/tests/data/Calculation/Engineering/DEC2HEX.php
index fd889afe..233f5d68 100644
--- a/tests/data/Calculation/Engineering/DEC2HEX.php
+++ b/tests/data/Calculation/Engineering/DEC2HEX.php
@@ -1,75 +1,37 @@
 <?php
 
 return [
-    [
-        '165',
-        '357',
-    ],
-    [
-        '54D',
-        '1357',
-    ],
-    [
-        'F6',
-        '246',
-    ],
-    [
-        '3039',
-        '12345',
-    ],
-    [
-        '75BCD15',
-        '123456789',
-    ],
-    [
-        '0064',
-        '100',
-        4,
-    ],
-    // Leading places as a float
-    [
-        '00064',
-        '100',
-        5.75,
-    ],
-    // Leading places negative
-    [
-        '#NUM!',
-        '100',
-        -1,
-    ],
-    // Leading places non-numeric
-    [
-        '#VALUE!',
-        '100',
-        'ABC',
-    ],
-    [
-        '7B',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    // Invalid decimal
-    [
-        '#VALUE!',
-        '3579A',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        'FFFFFFFFCA',
-        '-54',
-    ],
-    // 2's Complement
-    [
-        'FFFFFFFF95',
-        '-107',
-    ],
+    ['165', '357'],
+    ['54D', '1357'],
+    ['F6', '246'],
+    ['3039', '12345'],
+    ['75BCD15', '123456789'],
+    ['0064', '100, 4'],
+    ['00064', '100, 5.75'], // Leading places as a float
+    ['#NUM!', '100, -1'], // Leading places negative
+    ['#VALUE!', '100, "ABC"'], // Leading places non-numeric
+    ['7B', '123.45'],
+    ['0', '0'],
+    ['#VALUE!', '"3579A"'], // Invalid decimal
+    ['#VALUE!', 'true'], // ODS accepts boolean, Excel/Gnumeric don't
+    ['#VALUE!', 'false'],
+    ['FFFFFFFFCA', '-54'], // 2's Complement
+    ['FFFFFFFF95', '-107'], // 2's Complement
+    ['FF80000001', '-2147483647'], // 2's Complement
+    ['FF80000000', '-2147483648'], // 2's Complement
+    ['7FFFFFFFFF', 549755813887], // highest positive, succeeds even for 32-bit
+    ['#NUM!', 549755813888],
+    ['8000000000', -549755813888], // lowest negative, succeeds even for 32-bit
+    ['A2DE246000', -400000000000],
+    ['5D21DBA000', 400000000000],
+    ['#NUM!', -549755813889],
+    ['0103', '259, 4'],
+    ['#NUM!', '259, 0'],
+    ['#NUM!', '259, -1'],
+    ['#NUM!', '259, 14'],
+    ['#NUM!', '259, 1'],
+    ['103', '259, 3'],
+    ['11', 'A2'],
+    ['0', 'C2'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/DEC2OCT.php b/tests/data/Calculation/Engineering/DEC2OCT.php
index 59ae5a0d..631242d8 100644
--- a/tests/data/Calculation/Engineering/DEC2OCT.php
+++ b/tests/data/Calculation/Engineering/DEC2OCT.php
@@ -1,57 +1,27 @@
 <?php
 
 return [
-    [
-        '545',
-        '357',
-    ],
-    [
-        '2515',
-        '1357',
-    ],
-    [
-        '366',
-        '246',
-    ],
-    [
-        '30071',
-        '12345',
-    ],
-    [
-        '726746425',
-        '123456789',
-    ],
-    [
-        '173',
-        '123.45',
-    ],
-    [
-        '072',
-        '58',
-        3,
-    ],
-    [
-        '0',
-        '0',
-    ],
-    // Invalid decimal
-    [
-        '#VALUE!',
-        '3579A',
-    ],
-    // Non string
-    [
-        '#VALUE!',
-        true,
-    ],
-    // 2's Complement
-    [
-        '7777777634',
-        '-100',
-    ],
-    // 2's Complement
-    [
-        '7777777625',
-        '-107',
-    ],
+    ['545', '357'],
+    ['2515', '1357'],
+    ['366', '246'],
+    ['30071', '12345'],
+    ['726746425', '123456789'],
+    ['173', '123.45'],
+    ['072', '58, 3'],
+    ['0', '0'],
+    ['#VALUE!', '"3579A"'], // Invalid decimal
+    ['#VALUE!', 'true'], // ODS accepts bool, Excel/Gnumeric do not
+    ['#VALUE!', 'false'],
+    ['7777777634', '-100'], // 2's Complement
+    ['7777777625', '-107'], // 2's Complement
+    ['3777777777', 536870911], // highest positive
+    ['#NUM!', 536870912],
+    ['4000000000', -536870912], // lowest negative
+    ['#NUM!', -536870913],
+    ['0403', '259, 4'],
+    ['#NUM!', '259, 0'],
+    ['#NUM!', '259, -1'],
+    ['#NUM!', '259, 14'],
+    ['#NUM!', '259, 1'],
+    ['403', '259, 3'],
 ];
diff --git a/tests/data/Calculation/Engineering/HEX2BIN.php b/tests/data/Calculation/Engineering/HEX2BIN.php
index 76903007..879e83af 100644
--- a/tests/data/Calculation/Engineering/HEX2BIN.php
+++ b/tests/data/Calculation/Engineering/HEX2BIN.php
@@ -1,71 +1,33 @@
 <?php
 
 return [
-    [
-        '11111111',
-        'FF',
-    ],
-    [
-        '111111111',
-        '1FF',
-    ],
-    [
-        '#NUM!',
-        '200',
-    ],
-    // 2's Complement
-    [
-        '1000000000',
-        'FFFFFFFE00',
-    ],
-    // 2's Complement
-    [
-        '#NUM!',
-        'FFFFFFFDFF',
-    ],
-    [
-        '110101011',
-        '01AB',
-    ],
-    [
-        '#NUM!',
-        'ABCD',
-    ],
-    [
-        '11110110',
-        'F6',
-    ],
-    [
-        '00001111',
-        'F',
-        8,
-    ],
-    [
-        '10110111',
-        'B7',
-    ],
-    [
-        '#NUM!',
-        '12345',
-    ],
-    [
-        '#NUM!',
-        '123456789',
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#NUM!',
-        'G3579A',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
+    ['11111111', '"FF"'],
+    ['111111111', '"1FF"'],
+    ['#NUM!', '200'],
+    ['1000000000', '"FFFFFFFE00"'], // 2's Complement
+    ['#NUM!', '"FFFFFFFDFF"'], // 2's Complement
+    ['111111111', '"01FF"'], // highest positive
+    ['#NUM!', '"0200"'],
+    ['1000000000', '"FFFFFFFE00"'], // lowest negative
+    ['#NUM!', '"FFFFFFFDFF"'],
+    ['110101011', '"01AB"'],
+    ['#NUM!', '"ABCD"'],
+    ['11110110', '"F6"'],
+    ['00001111', '"F", 8'],
+    ['10110111', '"B7"'],
+    ['#NUM!', '12345'],
+    ['#NUM!', '123456789'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#NUM!', '"G3579A"'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['01010', '"A", 5'],
+    ['#NUM!', '"A", 0'],
+    ['#NUM!', '"A", -1'],
+    ['#NUM!', '"A", 14'],
+    ['#NUM!', '"A", 3'],
+    ['1010', '"A", 4'],
+    ['1011', 'A2'],
+    ['0', 'A3'],
 ];
diff --git a/tests/data/Calculation/Engineering/HEX2DEC.php b/tests/data/Calculation/Engineering/HEX2DEC.php
index c8bbd153..0ecdd30c 100644
--- a/tests/data/Calculation/Engineering/HEX2DEC.php
+++ b/tests/data/Calculation/Engineering/HEX2DEC.php
@@ -1,67 +1,27 @@
 <?php
 
 return [
-    [
-        '427',
-        '01AB',
-    ],
-    [
-        '43981',
-        'ABCD',
-    ],
-    [
-        '246',
-        'F6',
-    ],
-    [
-        '74565',
-        '12345',
-    ],
-    [
-        '4886718345',
-        '123456789',
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#NUM!',
-        'G3579A',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
-    [
-        '#NUM!',
-        '-107',
-    ],
-    [
-        '165',
-        'A5',
-    ],
-    [
-        '1034160313',
-        '3DA408B9',
-    ],
-    // 2's Complement
-    [
-        '-165',
-        'FFFFFFFF5B',
-    ],
-    // 2's Complement
-    [
-        '-1',
-        'FFFFFFFFFF',
-    ],
-    // Too large
-    [
-        '#NUM!',
-        '1FFFFFFFFFF',
-    ],
+    ['427', '"01AB"'],
+    ['43981', '"ABCD"'],
+    ['246', '"F6"'],
+    ['74565', '12345'],
+    ['4886718345', '123456789'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#NUM!', '"G3579A"'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['#NUM!', '-107'],
+    ['165', '"A5"'],
+    ['1034160313', '"3DA408B9"'],
+    ['-165', '"FFFFFFFF5B"'], // 2's Complement
+    ['-1', '"FFFFFFFFFF"'], // 2's Complement
+    ['#NUM!', '"1FFFFFFFFFF"'], // Too large
+    [11, 'A2'],
+    [0, 'A3'],
+    [549755813887, '"7fffffffff"'], // highest positive, succeeds even for 32-bit
+    [-549755813888, '"8000000000"'], // lowest negative, succeeds even for 32-bit
+    [-2147483648, '"ff80000000"'],
+    [2147483648, '"80000000"'],
+    [2147483647, '"7fffffff"'],
 ];
diff --git a/tests/data/Calculation/Engineering/HEX2OCT.php b/tests/data/Calculation/Engineering/HEX2OCT.php
index 9b2dd90d..0ee324ed 100644
--- a/tests/data/Calculation/Engineering/HEX2OCT.php
+++ b/tests/data/Calculation/Engineering/HEX2OCT.php
@@ -1,58 +1,30 @@
 <?php
 
 return [
-    [
-        '653',
-        '01AB',
-    ],
-    [
-        '125715',
-        'ABCD',
-    ],
-    [
-        '366',
-        'F6',
-    ],
-    [
-        '35516',
-        '3B4E',
-    ],
-    [
-        '017',
-        'F',
-        3,
-    ],
-    [
-        '221505',
-        '12345',
-    ],
-    [
-        '#NUM!',
-        '123456789',
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#NUM!',
-        'G3579A',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
-    [
-        '#NUM!',
-        '-107',
-    ],
-    // 2's Complement
-    [
-        '7777777400',
-        'FFFFFFFF00',
-    ],
+    ['653', '"01AB"'],
+    ['125715', '"ABCD"'],
+    ['366', '"F6"'],
+    ['35516', '"3B4E"'],
+    ['017', '"F", 3'],
+    ['221505', '12345'],
+    ['#NUM!', '123456789'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#NUM!', '"G3579A"'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['#NUM!', '-107'],
+    ['7777777400', '"FFFFFFFF00"'], // 2's Complement
+    ['3777777777', '"1FFFFFFF"'], // highest positive
+    ['#NUM!', '"20000000"'],
+    ['4000000000', '"FFE0000000"'], // lowest negative
+    ['#NUM!', '"FFDFFFFFFF"'],
+    ['00012', '"A", 5'],
+    ['#NUM!', '"A", 0'],
+    ['#NUM!', '"A", -1'],
+    ['#NUM!', '"A", 14'],
+    ['#NUM!', '"A", 1'],
+    ['12', '"A", 2'],
+    ['13', 'A2'],
+    ['0', 'A3'],
 ];
diff --git a/tests/data/Calculation/Engineering/OCT2BIN.php b/tests/data/Calculation/Engineering/OCT2BIN.php
index c4796110..ecccc3dc 100644
--- a/tests/data/Calculation/Engineering/OCT2BIN.php
+++ b/tests/data/Calculation/Engineering/OCT2BIN.php
@@ -1,61 +1,31 @@
 <?php
 
 return [
-    [
-        '#NUM!',
-        '1357',
-    ],
-    [
-        '10100110',
-        '246',
-    ],
-    [
-        '011',
-        '3',
-        3,
-    ],
-    [
-        '#NUM!',
-        '12345',
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
-    [
-        '#NUM!',
-        '3579',
-    ],
-    // 2's Complement
-    [
-        '1000000000',
-        '7777777000',
-    ],
-    // 2's Complement
-    [
-        '1111111111',
-        '7777777777',
-    ],
-    // Too small
-    [
-        '#NUM!',
-        '17777777777',
-    ],
-    [
-        '111111111',
-        '777',
-    ],
-    // Too large
-    [
-        '#NUM!',
-        '1777',
-    ],
+    ['#NUM!', '1357'],
+    ['10100110', '246'],
+    ['011', '3, 3'],
+    ['#NUM!', '12345'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['#NUM!', '3579'],
+    ['1000000000', '7777777000'], // 2's Complement
+    ['1111111111', '7777777777'], // 2's Complement
+    ['#NUM!', '17777777777'], // Too small
+    ['#NUM!', '1777'], // Too large
+    ['111111111', '777'], // highest positive
+    ['#NUM!', '1000'],
+    ['1000000000', '"7777777000"'], // lowest negative
+    ['#NUM!', '"7777776777"'],
+    ['01010', '12, 5'],
+    ['#NUM!', '12, 0'],
+    ['#NUM!', '12, -1'],
+    ['#NUM!', '12, 14'],
+    ['#NUM!', '12, 3'],
+    ['1010', '12, 4'],
+    ['1000001', 'A2'],
+    ['#NUM!', '"A2"'],
+    [0, 'A3'],
+    ['exception', ''],
 ];
diff --git a/tests/data/Calculation/Engineering/OCT2DEC.php b/tests/data/Calculation/Engineering/OCT2DEC.php
index 1d2ab60f..8ee3a170 100644
--- a/tests/data/Calculation/Engineering/OCT2DEC.php
+++ b/tests/data/Calculation/Engineering/OCT2DEC.php
@@ -1,41 +1,20 @@
 <?php
 
 return [
-    [
-        '751',
-        '1357',
-    ],
-    [
-        '166',
-        '246',
-    ],
-    [
-        '5349',
-        '12345',
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
-    [
-        '#NUM!',
-        '3579',
-    ],
-    [
-        '44',
-        '54',
-    ],
-    // 2's Complement
-    [
-        '-165',
-        '7777777533',
-    ],
+    ['751', '1357'],
+    ['166', '246'],
+    ['5349', '12345'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['#NUM!', '3579'],
+    ['44', '54'],
+    ['-165', '7777777533'], // 2's Complement
+    ['65', 'A2'],
+    ['0', 'A3'],
+    ['exception', ''],
+    ['#NUM!', '"37777777770"'], // too many digits
+    [536870911, '"3777777777"'], // highest positive
+    [-536870912, '"4000000000"'], // lowest negative
 ];
diff --git a/tests/data/Calculation/Engineering/OCT2HEX.php b/tests/data/Calculation/Engineering/OCT2HEX.php
index d688704f..137b96f4 100644
--- a/tests/data/Calculation/Engineering/OCT2HEX.php
+++ b/tests/data/Calculation/Engineering/OCT2HEX.php
@@ -1,42 +1,26 @@
 <?php
 
 return [
-    [
-        '2EF',
-        '1357',
-    ],
-    [
-        'A6',
-        '246',
-    ],
-    [
-        '14E5',
-        '12345',
-    ],
-    [
-        '0040',
-        '100',
-        4,
-    ],
-    [
-        '#NUM!',
-        '123.45',
-    ],
-    [
-        '0',
-        '0',
-    ],
-    [
-        '#VALUE!',
-        true,
-    ],
-    [
-        '#NUM!',
-        '3579',
-    ],
-    // 2's Complement
-    [
-        'FFFFFFFF5B',
-        '7777777533',
-    ],
+    ['2EF', '1357'],
+    ['A6', '246'],
+    ['14E5', '12345'],
+    ['0040', '100, 4'],
+    ['#NUM!', '123.45'],
+    ['0', '0'],
+    ['#VALUE!', 'true'],
+    ['#VALUE!', 'false'],
+    ['#NUM!', '3579'],
+    ['FFFFFFFF5B', '7777777533'], // 2's Complement
+    ['00108', '410, 5'],
+    ['#NUM!', '410, 0'],
+    ['#NUM!', '410, -1'],
+    ['#NUM!', '410, 14'],
+    ['#NUM!', '410, 2'],
+    ['108', '410, 3'],
+    ['41', 'A2'],
+    ['0', 'A3'],
+    ['exception', ''],
+    ['#NUM!', '"37777777770"'], // too many digits
+    ['1FFFFFFF', '"3777777777"'], // highest positive
+    ['FFE0000000', '"4000000000"'], // lowest negative
 ];