public static IEnumerable <object[]> TrySumLittleEndian_Test_Values()
        {
            var deltas = new[] { long.MinValue, -255, -129, -127, -1, 0, 1, 127, 129, 255, long.MaxValue };
            var uints  = new uint[] { uint.MinValue, 1, 127, 129, 255, uint.MaxValue };

            foreach (var delta in deltas)
            {
                foreach (var input in uints)
                {
                    var inputBytes = !BitConverter.IsLittleEndian
                                         ? BitConverter.GetBytes(input)
                                     .ReverseBytes()
                                         : BitConverter.GetBytes(input);

                    var deltaBytes = !BitConverter.IsLittleEndian
                                         ? BitConverter.GetBytes(delta)
                                     .ReverseBytes()
                                         : BitConverter.GetBytes(delta);

                    if (delta < 0 &&
                        input - delta < 0)
                    {
                        yield return(new object[] { false, Array.Empty <byte>(), inputBytes, delta });

                        yield break;
                    }

                    var expectedBytes = delta < 0
                                            ? ByteArrayUtils.SubtractUnsignedLittleEndian(inputBytes, deltaBytes)
                                            : ByteArrayUtils.AddUnsignedLittleEndian(inputBytes, deltaBytes);

                    yield return(new object[] { true, expectedBytes, inputBytes, delta });
                }
            }
        }
 public void AddUnsignedLittleEndian_NullInput_ThrowsArgumentNullException_Test(byte[] left,
                                                                                byte[] right)
 {
     // Arrange
     // Act
     // Assert
     Assert.Throws <ArgumentNullException>(() => ByteArrayUtils.AddUnsignedLittleEndian(left, right));
 }
        public void AddUnsignedLittleEndian_Test(byte[] expected,
                                                 byte[] left,
                                                 byte[] right)
        {
            // Arrange
            var leftOriginal  = left.ToArray();
            var rightOriginal = right.ToArray();

            // Act
            var result = ByteArrayUtils.AddUnsignedLittleEndian(left, right);

            // Assert
            Assert.Equal(expected, result);

            Assert.Equal(leftOriginal, left);   // input value not affected
            Assert.Equal(rightOriginal, right); // input value not affected
        }
Пример #4
0
        public static void AddUnsignedLittleEndianExample()
        {
            // Setup
            var lhs = new byte[] { 0xAD, 0xDE, 0xD0 };
            var rhs = new byte[] { 0xC0, 0xDE };

            // Act
            var result = ByteArrayUtils.AddUnsignedLittleEndian(lhs, rhs);

            // Conclusion
            Console.WriteLine("AddUnsignedLittleEndian Example");
            Console.WriteLine($"lhs:\t{lhs.ToString("H")}");
            Console.WriteLine($"rhs:\t{rhs.ToString("H")}");
            Console.WriteLine($"result:\t{result.ToString("H")}");
            Console.WriteLine(string.Empty);

            Console.WriteLine($"lhs:\t{lhs.ToString("ILE")}");
            Console.WriteLine($"rhs:\t{rhs.ToString("ILE")}");
            Console.WriteLine($"result:\t{result.ToString("ILE")}");
            Console.WriteLine(string.Empty);
        }