public void When_Comparing_And_LeftIsNull_And_RightHasValue_Should_ReturnNoDifferences()
        {
            var item = new DataComparisonItem(null, new byte[] { 3, 4, 5 });
            var result = item.Compare();

            Assert.Null(result.Differences);
        }
        public void When_Comparing_And_LeftIsNull_And_RightHasValue_Should_ReturnDifferentSizeState()
        {
            var item = new DataComparisonItem(null, new byte[] { 3, 4, 5 });
            var result = item.Compare();

            Assert.NotNull(result);
            Assert.Equal(ComparisonState.DifferentSize, result.ComparisonState);
        }
        public void When_Comparing_And_LeftIsNull_And_RightIsNull_Should_ReturnEqualState()
        {
            var item = new DataComparisonItem(null, null);
            var result = item.Compare();

            Assert.NotNull(result);
            Assert.Equal(ComparisonState.Equal, result.ComparisonState);
        }
        public void When_Comparing_And_DataHasEqualSizeButDifferentContent_Should_ReturnDifferences()
        {
            var left  = new byte[] {0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
            var right = new byte[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
            var item = new DataComparisonItem(left, right);

            var result = item.Compare();
            Assert.NotNull(result.Differences);
            Assert.Equal(5, result.Differences.Count);

            var diff1 = result.Differences.ElementAt(0);
            Assert.Equal(0, diff1.Offset);
            Assert.Equal(1, diff1.Length);

            var diff2 = result.Differences.ElementAt(1);
            Assert.Equal(2, diff2.Offset);
            Assert.Equal(1, diff2.Length);

            var diff3 = result.Differences.ElementAt(2);
            Assert.Equal(4, diff3.Offset);
            Assert.Equal(1, diff3.Length);

            var diff4 = result.Differences.ElementAt(3);
            Assert.Equal(6, diff4.Offset);
            Assert.Equal(1, diff4.Length);

            var diff5 = result.Differences.ElementAt(4);
            Assert.Equal(8, diff5.Offset);
            Assert.Equal(1, diff5.Length);
        }
        public void When_Comparing_And_DataHasEqualSizeButDifferentContent_Should_ReturnDifferentContentState()
        {
            var left  = new byte[] {0, 1, 0, 1, 0, 1, 0, 1, 0, 1};
            var right = new byte[] {1, 1, 1, 1, 1, 1, 1, 1, 1, 1};
            var item = new DataComparisonItem(left, right);

            var result = item.Compare();
            Assert.NotNull(result);
            Assert.Equal(ComparisonState.DifferentContent, result.ComparisonState);
        }
        public void When_ComparingLargeData_And_RightEqualsLeft_Should_Succeed()
        {
            var size = 50 * 1024 * 1024; // 50MB
            //var size = int.MaxValue; // ~2GB
            var item = new DataComparisonItem(new byte[size], new byte[size]);
            var result = item.Compare();

            Assert.NotNull(result);
            Assert.Equal(ComparisonState.Equal, result.ComparisonState);
        }
        public void When_Comparing_And_DataEqualsEmptyArray_Should_ReturnEqualState()
        {
            var item = new DataComparisonItem(new byte[] { }, new byte[] { });
            var result = item.Compare();

            Assert.NotNull(result);
            Assert.Equal(ComparisonState.Equal, result.ComparisonState);
        }
        public void When_Comparing_And_RightEqualsLeft_Should_ReturnNoDifferences()
        {
            var item = new DataComparisonItem(new byte[] { 0, 1, 2 }, new byte[] { 0, 1, 2 });
            var result = item.Compare();

            Assert.Null(result.Differences);
        }
        public void When_Comparing_And_RightEqualsLeft_Should_ReturnEqualState()
        {
            var item = new DataComparisonItem(new byte[] { 0, 1, 2 }, new byte[] { 0, 1, 2 });
            var result = item.Compare();

            Assert.NotNull(result);
            Assert.Equal(ComparisonState.Equal, result.ComparisonState);
        }