Add Arithmetic Binary Operators tests

2026-02-04 05:36:05 +00:00 · 2025-10-27 16:18:45 -04:00
parent 1eaf7954fe
commit 65dbb7a31a
8 changed files with 256 additions and 0 deletions
--- a/SabreTools.IO.Test/Numerics/BothInt16Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothInt16Tests.cs
@@ -159,6 +159,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothInt16(3, 3);
+            var valB = new BothInt16(2, 2);
+
+            short expected = 6;
+            BothInt16 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothInt32Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothInt32Tests.cs
@@ -159,6 +159,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothInt32(3, 3);
+            var valB = new BothInt32(2, 2);
+
+            int expected = 6;
+            BothInt32 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothInt64Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothInt64Tests.cs
@@ -159,6 +159,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothInt64(3, 3);
+            var valB = new BothInt64(2, 2);
+
+            long expected = 6;
+            BothInt64 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothInt8Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothInt8Tests.cs
@@ -159,6 +159,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothInt8(3, 3);
+            var valB = new BothInt8(2, 2);
+
+            sbyte expected = 6;
+            BothInt8 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothUInt16Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothUInt16Tests.cs
@@ -149,6 +149,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothUInt16(3, 3);
+            var valB = new BothUInt16(2, 2);
+
+            ushort expected = 6;
+            BothUInt16 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothUInt32Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothUInt32Tests.cs
@@ -149,6 +149,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothUInt32(3, 3);
+            var valB = new BothUInt32(2, 2);
+
+            uint expected = 6;
+            BothUInt32 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothUInt64Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothUInt64Tests.cs
@@ -149,6 +149,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothUInt64(3, 3);
+            var valB = new BothUInt64(2, 2);
+
+            ulong expected = 6;
+            BothUInt64 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {
--- a/SabreTools.IO.Test/Numerics/BothUInt8Tests.cs
+++ b/SabreTools.IO.Test/Numerics/BothUInt8Tests.cs
@@ -149,6 +149,38 @@ namespace SabreTools.IO.Test.Numerics
            Assert.Equal(expected, actual.BigEndian);
        }

+        [Fact]
+        public void ArithmeticBinaryOperatorsTest()
+        {
+            var valA = new BothUInt8(3, 3);
+            var valB = new BothUInt8(2, 2);
+
+            byte expected = 6;
+            BothUInt8 actual = valA * valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA / valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA % valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 5;
+            actual = valA + valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+
+            expected = 1;
+            actual = valA - valB;
+            Assert.Equal(expected, actual.LittleEndian);
+            Assert.Equal(expected, actual.BigEndian);
+        }
+
        [Fact]
        public void OperatorsTest()
        {