public void WorksWithNonIComparableTuples()
        {
            var message3 = new object();
            var message4 = new object();
            var actual   = new[]
            {
                new Tuple <int, object, CancellationToken>(1, message3, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(2, message3, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(1, message4, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(2, message4, CancellationToken.None)
            };

            var expected = new[]
            {
                new Tuple <int, object, CancellationToken>(1, message4, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(2, message4, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(1, message3, CancellationToken.None),
                new Tuple <int, object, CancellationToken>(2, message3, CancellationToken.None)
            };

            var constraint = new CollectionEquivalentConstraint(expected);
            var result     = constraint.ApplyTo(actual);

            Assert.That(result.IsSuccess);
        }
        public void WorksWithCollectionsOfArrays()
        {
            byte[] array1 = new byte[] { 0x20, 0x44, 0x56, 0x76, 0x1e, 0xff };
            byte[] array2 = new byte[] { 0x42, 0x52, 0x72, 0xef };
            byte[] array3 = new byte[] { 0x20, 0x44, 0x56, 0x76, 0x1e, 0xff };
            byte[] array4 = new byte[] { 0x42, 0x52, 0x72, 0xef };

            ICollection set1 = new SimpleObjectCollection(array1, array2);
            ICollection set2 = new SimpleObjectCollection(array3, array4);

            Constraint constraint = new CollectionEquivalentConstraint(set1);
            Assert.That(constraint.ApplyTo(set2).IsSuccess);

            set2 = new SimpleObjectCollection(array4, array3);
            Assert.That(constraint.ApplyTo(set2).IsSuccess);
        }
        public void WorksWithCollectionsOfArrays()
        {
            byte[] array1 = new byte[] { 0x20, 0x44, 0x56, 0x76, 0x1e, 0xff };
            byte[] array2 = new byte[] { 0x42, 0x52, 0x72, 0xef };
            byte[] array3 = new byte[] { 0x20, 0x44, 0x56, 0x76, 0x1e, 0xff };
            byte[] array4 = new byte[] { 0x42, 0x52, 0x72, 0xef };

            ICollection set1 = new SimpleObjectCollection(array1, array2);
            ICollection set2 = new SimpleObjectCollection(array3, array4);

            Constraint constraint = new CollectionEquivalentConstraint(set1);

            Assert.That(constraint.ApplyTo(set2).IsSuccess);

            set2 = new SimpleObjectCollection(array4, array3);
            Assert.That(constraint.ApplyTo(set2).IsSuccess);
        }
        public void WorksWithArrayAndHashSet()
        {
            var hash  = new HashSet <string>(new string[] { "presto", "abracadabra", "hocuspocus" });
            var array = new string[] { "abracadabra", "presto", "hocuspocus" };

            var constraint = new CollectionEquivalentConstraint(array);

            Assert.That(constraint.ApplyTo(hash).IsSuccess);
        }
        public void HonorsIgnoreCase(IEnumerable expected, IEnumerable actual)
        {
            var constraint       = new CollectionEquivalentConstraint(expected).IgnoreCase;
            var constraintResult = constraint.ApplyTo(actual);

            if (!constraintResult.IsSuccess)
            {
                MessageWriter writer = new TextMessageWriter();
                constraintResult.WriteMessageTo(writer);
                Assert.Fail(writer.ToString());
            }
        }
        public void FailureMessageWithHashSetAndArray()
        {
            var hash  = new HashSet <string>(new string[] { "presto", "abracadabra", "hocuspocus" });
            var array = new string[] { "abracadabra", "presto", "hocusfocus" };

            var constraint       = new CollectionEquivalentConstraint(hash);
            var constraintResult = constraint.ApplyTo(array);

            Assert.False(constraintResult.IsSuccess);

            TextMessageWriter writer = new TextMessageWriter();

            constraintResult.WriteMessageTo(writer);
            Assert.That(writer.ToString(), Is.EqualTo(
                            "  Expected: equivalent to < \"presto\", \"abracadabra\", \"hocuspocus\" >" + Environment.NewLine +
                            "  But was:  < \"abracadabra\", \"presto\", \"hocusfocus\" >" + Environment.NewLine));
            //Console.WriteLine(writer.ToString());
        }
        public void LargeStringCollectionsInReversedOrder()
        {
            var actual   = Enumerable.Range(0, SIZE).Select(i => i.ToString()).ToList();
            var expected = Enumerable.Range(0, SIZE).Select(i => (SIZE - i - 1).ToString()).ToList();

            var watch = Stopwatch.StartNew();

            var constraint       = new CollectionEquivalentConstraint(actual);
            var constraintResult = constraint.ApplyTo(expected);

            Assert.That(constraintResult.IsSuccess, Is.True);

            watch.Stop();
            if (watch.ElapsedMilliseconds > LARGE_COLLECTION_WARN_TIME)
            {
                Assert.Warn($"{TestContext.CurrentContext.Test.MethodName} took {watch.ElapsedMilliseconds} ms.");
            }
        }
        public void TestOneMissingValue()
        {
            List <object> actualList = new List <object>()
            {
                "one"
            };

            ConstraintResult cr = _constraint.ApplyTo(actualList);

            cr.WriteMessageTo(_writer);

            string expectedMsg =
                "  Expected: equivalent to < \"one\", \"two\" >" + Environment.NewLine +
                "  But was:  < \"one\" >" + Environment.NewLine +
                "  Missing (1): < \"two\" >" + Environment.NewLine;

            Assert.AreEqual(expectedMsg, _writer.ToString());
        }
        public void LargeByteCollectionsNotEquivalentAtEnd()
        {
            byte[] data      = new byte[SIZE];
            byte[] encrypted = new byte[SIZE];
            encrypted[SIZE - 2] = 2;
            encrypted[SIZE - 1] = 3;

            var watch = Stopwatch.StartNew();

            var constraint       = new CollectionEquivalentConstraint(data);
            var constraintResult = constraint.ApplyTo(encrypted);

            Assert.That(constraintResult.IsSuccess, Is.False);

            watch.Stop();
            if (watch.ElapsedMilliseconds > LARGE_COLLECTION_WARN_TIME)
            {
                Assert.Warn($"{TestContext.CurrentContext.Test.MethodName} took {watch.ElapsedMilliseconds} ms.");
            }
        }
        public void LargeStringCollection()
        {
            var actual   = new StringCollection();
            var expected = new StringCollection();

            foreach (var i in Enumerable.Range(0, SIZE))
            {
                actual.Add(i.ToString());
                expected.Add(i.ToString());
            }

            var watch = Stopwatch.StartNew();

            var constraint       = new CollectionEquivalentConstraint(actual);
            var constraintResult = constraint.ApplyTo(expected);

            Assert.That(constraintResult.IsSuccess, Is.True);

            watch.Stop();
            if (watch.ElapsedMilliseconds > LARGE_COLLECTION_WARN_TIME)
            {
                Assert.Warn($"{TestContext.CurrentContext.Test.MethodName} took {watch.ElapsedMilliseconds} ms.");
            }
        }
        public void FailureMessageWithHashSetAndArray()
        {
            var hash = new HashSet<string>(new string[] { "presto", "abracadabra", "hocuspocus" });
            var array = new string[] { "abracadabra", "presto", "hocusfocus" };

            var constraint = new CollectionEquivalentConstraint(hash);
            var constraintResult = constraint.ApplyTo(array);
            Assert.False(constraintResult.IsSuccess);

            TextMessageWriter writer = new TextMessageWriter();
            constraintResult.WriteMessageTo(writer);
            Assert.That(writer.ToString(), Is.EqualTo(
                "  Expected: equivalent to < \"presto\", \"abracadabra\", \"hocuspocus\" >" + Environment.NewLine +
                "  But was:  < \"abracadabra\", \"presto\", \"hocusfocus\" >" + Environment.NewLine));
            //Console.WriteLine(writer.ToString());
        }
        public void WorksWithArrayAndHashSet()
        {
            var hash = new HashSet<string>(new string[] { "presto", "abracadabra", "hocuspocus" });
            var array = new string[] { "abracadabra", "presto", "hocuspocus" };

            var constraint = new CollectionEquivalentConstraint(array);
            Assert.That(constraint.ApplyTo(hash).IsSuccess);
        }
 public void HonorsIgnoreCase( IEnumerable expected, IEnumerable actual )
 {
     var constraint = new CollectionEquivalentConstraint( expected ).IgnoreCase;
     var constraintResult = constraint.ApplyTo( actual );
     if ( !constraintResult.IsSuccess )
     {
         MessageWriter writer = new TextMessageWriter();
         constraintResult.WriteMessageTo( writer );
         Assert.Fail( writer.ToString() );
     }
 }