public void IsArrayType()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsArrayType(null as object));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsArrayType(null as Type));

            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType("hello"));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(1L));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(AttributeTargets.All));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(new List <int>()));
            Assert.DoesNotThrow(() => Assert.IsArrayType(new int[0]));

            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType <string>());
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType <long>());
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType <AttributeTargets>());
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType <List <int> >());
            Assert.DoesNotThrow(() => Assert.IsArrayType <int[]>());
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType <IEnumerable <int> >());

            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(typeof(string)));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(typeof(long)));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(typeof(AttributeTargets)));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(typeof(List <int>)));
            Assert.DoesNotThrow(() => Assert.IsArrayType(typeof(int[])));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsArrayType(typeof(IEnumerable <int>)));
        }
 public void NotEmpty()
 {
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.NotEmpty <int>(null));
     Assert.ThrowsExact <AssertionException>(() => Assert.NotEmpty(new int[] { }));
     Assert.ThrowsExact <AssertionException>(() => Assert.NotEmpty(string.Empty));
     Assert.DoesNotThrow(() => Assert.NotEmpty(new[] { 1, 2, 3 }));
 }
 public void Null()
 {
     Assert.DoesNotThrow(() => Assert.Null(null as string));
     Assert.DoesNotThrow(() => Assert.Null(null as int?));
     Assert.ThrowsExact <AssertionException>(() => Assert.Null(new object()));
     Assert.ThrowsExact <AssertionException>(() => Assert.Null((1 as int?)));
 }
 public void IsWithinDelta()
 {
     Assert.DoesNotThrow(() => Assert.IsWithinDelta(0.0001f, 0.0002f, 0.0001f));
     Assert.DoesNotThrow(() => Assert.IsWithinDelta(0.0001d, 0.0002d, 0.0001d));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsWithinDelta(0.0001f, 0.0002f, 0.00002f));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsWithinDelta(0.0001d, 0.0002d, 0.00002d));
 }
        public void ThrowsExactPredicate()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.ThrowsExact <AssertionException>(null, e => e != null));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.ThrowsExact <AssertionException>(EmptyNoThrow, null as Func <AssertionException, bool>));
            Assert.DoesNotThrow(() => Assert.ThrowsExact <Exception>(ThrowsPlain, e => e != null));

            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <DerivedExceptionTest>(ThrowsBase, e => e != null));
            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <ArgumentException>(EmptyNoThrow, e => e != null));
            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <NotSupportedException>(() => { throw new ArgumentNullException(); }, e => e != null));
            Assert.DoesNotThrow(() => Assert.ThrowsExact <DerivedExceptionTest>(ThrowsDerived, e => e != null));
            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <ExceptionTest>(ThrowsDerived, e => e != null));
            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <DerivedExceptionTest>(ThrowsDerived, e => e == null));
            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <ExceptionTest>(ThrowsDerived, e => e == null));

            try {
                Assert.ThrowsExact <ArgumentNullException>(() => { throw new InvalidOperationException("Testing"); }, e => e != null);
                // This should not occur
                throw new InvalidOperationException();
            }
            catch (AssertionException e) {
                if (e.InnerException.GetType() != typeof(InvalidOperationException))
                {
                    // This should not occur
                    throw;
                }
            }
            catch (Exception) {
                // This should not occur
                throw;
            }

            Assert.ThrowsExact <AssertionException>(() => Assert.ThrowsExact <Exception>(() => { throw new Exception(); }, e => e.InnerException != null));
            Assert.DoesNotThrow(() => Assert.ThrowsExact <Exception>(() => { throw new Exception("Test", new InvalidOperationException("Inner")); }, e => e.InnerException != null && e.InnerException.GetType() == typeof(InvalidOperationException) && e.InnerException.Message == "Inner"));
        }
Beispiel #6
0
        public void CombinedErrAndOutPlusTwoNumber()
        {
            ProcessResult result = null;

            Assert.DoesNotThrow(() => {
                using (var process = new ProcessSpawnerWithCombinedErrAndOut(TestApplications.PlusTwoNumberInfo)) {
                    process.OnInputRequested += (buf, writer) => {
                        if (string.IsNullOrEmpty(buf))
                        {
                            return(ProcessInputHandleResult.Ignored);
                        }
                        if (buf == "878")
                        {
                            return(ProcessInputHandleResult.Ignored);
                        }
                        if (buf != "Please enter a number...")
                        {
                            Assert.Fail();
                            return(ProcessInputHandleResult.Ignored);
                        }
                        writer.WriteLine("876");
                        return(ProcessInputHandleResult.Handled);
                    };

                    result = process.Run();
                }
            });
            Assert.NotNull(result);
            Assert.NotNull(result.FullOutput);
            Assert.Equal(result.FullOutput, @"Please enter a number...
878");

            Assert.DoesNotThrow(() => {
                using (var process = new ProcessSpawnerWithCombinedErrAndOut(TestApplications.PlusTwoNumberInfo)) {
                    process.OnInputRequested += (buf, writer) => {
                        if (string.IsNullOrEmpty(buf))
                        {
                            return(ProcessInputHandleResult.Ignored);
                        }
                        if (buf == "Bad number")
                        {
                            return(ProcessInputHandleResult.Ignored);
                        }
                        if (buf != "Please enter a number...")
                        {
                            Assert.Fail();
                            return(ProcessInputHandleResult.Ignored);
                        }
                        writer.WriteLine("abc");
                        return(ProcessInputHandleResult.Handled);
                    };

                    result = process.Run();
                }
            });
            Assert.NotNull(result);
            Assert.NotNull(result.FullOutput);
            Assert.Equal(result.FullOutput, @"Please enter a number...
Bad number");
        }
Beispiel #7
0
        public void CombinedErrAndOutSimpleInterspersed()
        {
            ProcessResult result = null;

            Assert.DoesNotThrow(() => {
                using (var process = new ProcessSpawnerWithCombinedErrAndOut(TestApplications.SimpleInterspersedInfo)) {
                    result = process.Run();
                }
            });
            Assert.NotNull(result);
            Assert.Equal(result.ExitCode, 3);
            Assert.GreaterThan(result.PeakPagedMemorySize, 0);
            Assert.GreaterThan(result.PeakVirtualMemorySize, 0);
            Assert.GreaterThan(result.PeakWorkingSet, 0);
            Assert.NotEqual(result.StartTime, DateTime.MinValue);
            Assert.NotEqual(result.ExitTime, DateTime.MinValue);
            Assert.GreaterThan(result.ExitTime - result.StartTime, TimeSpan.Zero);
            Assert.NotNull(result.FullOutput);
            Assert.Null(result.FullStd);
            Assert.Null(result.FullError);
            Assert.Equal(result.FullOutput, @"abc
def
abc
def
abc
def
def
abc
aabbccddeeff");
        }
Beispiel #8
0
        public void CombinedAndSplitErrAndOutNakedInput()
        {
            ProcessResult result = null;

            Assert.DoesNotThrow(() => {
                using (var process = new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.NakedInput)) {
                    process.OnInputRequested += (buf, writer) => {
                        if (!string.IsNullOrEmpty(buf) && buf != "acb876")
                        {
                            Assert.Fail();
                        }
                        writer.WriteLine("acb876");
                        return(ProcessInputHandleResult.Handled);
                    };

                    result = process.Run();
                }
            });
            Assert.NotNull(result);
            Assert.NotNull(result.FullOutput);
            Assert.NotNull(result.FullStd);
            Assert.NotNull(result.FullError);
            Assert.Equal(result.FullOutput, @"acb876");
            Assert.Equal(result.FullStd, @"acb876");
            Assert.Equal(result.FullError, @"");
        }
Beispiel #9
0
        public void CombinedAndSplitErrAndOutConstructor()
        {
            // File only
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string)) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo)) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty)) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary)) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo)) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed)) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo)) { } });

            // File/args only
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, null as object[])) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, "abc")) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, "abc")) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, "abc")) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, null as object[])) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, null as object[])) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, "abc")) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, "abc")) { } });

            // File/escaper/args
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, null, null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, null, null as object[])) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, null, null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, null, null as object[])) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, null, null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as string, null, "abc")) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(null as FileInfo, null, "abc")) { } });
            Assert.ThrowsExact <ArgumentException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(string.Empty, null, "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinary, null, "abc")) { } });
            Assert.ThrowsExact <FileNotFoundException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.InvalidBinaryInfo, null, "abc")) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, null, null as object[])) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, null, null as object[])) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, new WindowsCommandLineArgumentEscaper(), null as object[])) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, null, "abc")) { } });
            Assert.ThrowsExact <ArgumentNullException>(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, null, "abc")) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersed, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
            Assert.DoesNotThrow(() => { using (new ProcessSpawnerWithCombinedAndSplitErrAndOut(TestApplications.SimpleInterspersedInfo, new WindowsCommandLineArgumentEscaper(), "abc")) { } });
        }
        public void CountSequence()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Count(null as int[], 1));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Count(new int[] { }, 1));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Count(new int[] { 0 }, -1));

            Assert.DoesNotThrow(() => Assert.Count(new int[] { 1, 2, 3, 4, 5 }, 5));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count(new int[] { 1, 2, 3, 4, 5 }, 4));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count(new int[] { 1, 2, 3, 4, 5 }, 6));
        }
 public void DirectoryNotExists()
 {
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.DirectoryNotExists(null as string));
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.DirectoryNotExists(null as DirectoryInfo));
     Assert.DoesNotThrow(() => Assert.DirectoryNotExists(NonExistingDirectory));
     Assert.DoesNotThrow(() => Assert.DirectoryNotExists(NonExistingDirectoryInfo));
     Assert.DoesNotThrow(() => Assert.DirectoryNotExists(new DirectoryInfo(NonExistingDirectory)));
     Assert.ThrowsExact <AssertionException>(() => Assert.DirectoryNotExists(ExistingDirectory));
     Assert.ThrowsExact <AssertionException>(() => Assert.DirectoryNotExists(ExistingDirectoryInfo));
 }
 public void FileNotExists()
 {
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.FileNotExists(null as string));
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.FileNotExists(null as FileInfo));
     Assert.DoesNotThrow(() => Assert.FileNotExists(NonExistingFile));
     Assert.DoesNotThrow(() => Assert.FileNotExists(NonExistingFileInfo));
     Assert.DoesNotThrow(() => Assert.FileNotExists(new FileInfo(NonExistingFile)));
     Assert.ThrowsExact <AssertionException>(() => Assert.FileNotExists(ExistingFile));
     Assert.ThrowsExact <AssertionException>(() => Assert.FileNotExists(ExistingFileInfo));
 }
 public void DoesNotContain()
 {
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.DoesNotContain <int>(null, 1));
     Assert.ThrowsExact <ArgumentNullException>(() => Assert.DoesNotContain("ABC", 'c', null as IEqualityComparer <char>));
     Assert.ThrowsExact <ArgumentException>(() => Assert.DoesNotContain <int>(new int[] { }, 1));
     Assert.DoesNotThrow(() => Assert.DoesNotContain(new int[] { 2 }, 1));
     Assert.ThrowsExact <AssertionException>(() => Assert.DoesNotContain(new int[] { 2 }, 2));
     Assert.DoesNotThrow(() => Assert.DoesNotContain("ABC", 'd', new CharCaseInvariantComparer()));
     Assert.ThrowsExact <AssertionException>(() => Assert.DoesNotContain("ABC", 'c', new CharCaseInvariantComparer()));
 }
        public void IsNotMatch()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotMatch(null as Regex, string.Empty));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotMatch(new Regex(string.Empty), null));

            Assert.DoesNotThrow(() => Assert.IsNotMatch("abc", "cba"));
            Assert.DoesNotThrow(() => Assert.IsNotMatch(new Regex("abc"), "cba"));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotMatch("abc", "abc"));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotMatch(new Regex("abc"), "abc"));
        }
 public void False()
 {
     Assert.Throws <ArgumentNullException>(() => Assert.False(null as Func <bool>));
     Assert.DoesNotThrow(() => Assert.False(false));
     Assert.DoesNotThrow(() => Assert.False(() => false));
     Assert.ThrowsExact <AssertionException>(() => Assert.False(true));
     Assert.ThrowsExact <AssertionException>(() => Assert.False(null as bool?));
     Assert.ThrowsExact <AssertionException>(() => Assert.False(() => true));
     Assert.ThrowsExact <AssertionException>(() => Assert.False(() => null as bool?));
 }
        public void None()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.None(null as int[], v => v == 0));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.None(new int[] { }, null));
            Assert.ThrowsExact <ArgumentException>(() => Assert.None(new int[] { }, v => v == 0));

            Assert.ThrowsExact <AssertionException>(() => Assert.None(new int[] { 1, 2, 3, 4, 5 }, v => v >= 3));
            Assert.DoesNotThrow(() => Assert.None(new int[] { 1, 2, 3, 4, 5 }, v => v > 10));
            Assert.ThrowsExact <AssertionException>(() => Assert.None(new int[] { 1, 2, 3, 4, 5 }, v => v == 1));
        }
 public void IsNegativeInfinity()
 {
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(float.NaN));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(double.NaN));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(float.PositiveInfinity));
     Assert.DoesNotThrow(() => Assert.IsNegativeInfinity(float.NegativeInfinity));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(1.34f));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(double.PositiveInfinity));
     Assert.DoesNotThrow(() => Assert.IsNegativeInfinity(double.NegativeInfinity));
     Assert.ThrowsExact <AssertionException>(() => Assert.IsNegativeInfinity(1.34d));
 }
        public void ExceptionAttachments()
        {
            var exception = new AssertionException("Testing {0}", 123);

            try {
                Assert.DoesNotThrow(() => { throw new ArgumentException(); }, exception);
            }
            catch (AssertionException e) {
                Assert.Equal(e.Message, "Testing 123");
            }
        }
 public void NotSame()
 {
     Assert.ThrowsExact <AssertionException>(() => Assert.NotSame <object>(null, null));
     Assert.ThrowsExact <AssertionException>(() => {
         object o = new object();
         Assert.NotSame(o, o);
     });
     Assert.DoesNotThrow(() => Assert.NotSame(new object(), null));
     Assert.DoesNotThrow(() => Assert.NotSame(null, new object()));
     Assert.DoesNotThrow(() => Assert.NotSame(new object(), new object()));
 }
        public void Equal()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Equal(null as object, null as object, null as IEqualityComparer <object>));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Equal(null as object, null as object, null as IEqualityComparer));

            Assert.DoesNotThrow(() => Assert.Equal(1, 1));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(1, 0));
            Assert.DoesNotThrow(() => Assert.Equal(null, null));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(null as string, "hello"));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(null as string, 0));

            Assert.ThrowsExact <AssertionException>(() => Assert.Equal("000", "0000"));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(new[] { 1, 2 }, new[] { 1, 2, 3 }));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(new[] { 1, 2, 4 }, new[] { 1, 2, 3 }));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(new[] { 1, 2 }, null));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(new[] { 1, 2 }, new List <int>()
            {
                1, 2
            }));
            Assert.DoesNotThrow(() => Assert.Equal(new[] { 1, 2, 3 }, new[] { 1, 2, 3 }));

            var arr1 = new[] {
                new[] { 1, 2 },
                new[] { 2, 1 },
            };

            Assert.DoesNotThrow(() => Assert.Equal(arr1, arr1));

            var arr2 = new[] {
                new[] { 2, 1 },
                new[] { 1, 2 },
            };

            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(arr1, arr2));

            arr2 = new[] {
                new[] { 1, 2 },
                new[] { 2, 1 },
            };
            Assert.DoesNotThrow(() => Assert.Equal(arr1, arr2));

            var enumImpl1 = new EnumerableImpl(1, 2);
            var enumImpl2 = new EnumerableImpl(2, 1);

            Assert.DoesNotThrow(() => Assert.Equal(enumImpl1, enumImpl1));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal(enumImpl1, enumImpl2));
            enumImpl2 = new EnumerableImpl(1, 2);
            Assert.DoesNotThrow(() => Assert.Equal(enumImpl1, enumImpl2));

            Assert.DoesNotThrow(() => Assert.Equal("abc", "ABC", StringComparer.InvariantCultureIgnoreCase));
            Assert.DoesNotThrow(() => Assert.Equal("abc" as object, "ABC" as object, StringComparer.InvariantCultureIgnoreCase));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal("abc", "BBB", StringComparer.InvariantCultureIgnoreCase));
            Assert.ThrowsExact <AssertionException>(() => Assert.Equal("abc" as object, "BBB" as object, StringComparer.InvariantCultureIgnoreCase));
        }
        public void GreaterThan()
        {
            int minValue = 1;
            int value    = 2;

            Assert.ThrowsExact <ArgumentNullException>(() => Assert.GreaterThan <string>(null, "z"));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.GreaterThan <string>("a", null));
            Assert.DoesNotThrow(() => Assert.GreaterThan(value, minValue));
            Assert.ThrowsExact <AssertionException>(() => Assert.GreaterThan(minValue, minValue));
            Assert.ThrowsExact <AssertionException>(() => Assert.GreaterThan(minValue - 5, minValue));
            Assert.DoesNotThrow(() => Assert.GreaterThan(minValue + 5, minValue));
        }
        public void LessThanEqual()
        {
            int minValue = 1;
            int value    = 2;

            Assert.ThrowsExact <ArgumentNullException>(() => Assert.LessThanEqual <string>(null, "z"));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.LessThanEqual <string>("a", null));
            Assert.ThrowsExact <AssertionException>(() => Assert.LessThanEqual(value, minValue));
            Assert.DoesNotThrow(() => Assert.LessThanEqual(minValue, minValue));
            Assert.DoesNotThrow(() => Assert.LessThanEqual(minValue - 5, minValue));
            Assert.ThrowsExact <AssertionException>(() => Assert.LessThanEqual(minValue + 5, minValue));
        }
        public void Exactly()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Exactly(null as int[], 1, v => v == 0));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Exactly(new int[] { }, 1, null));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Exactly(new int[] { }, 1, v => v == 0));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Exactly(new int[] { 0 }, -1, v => v == 0));

            Assert.DoesNotThrow(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 3, v => v >= 3));
            Assert.DoesNotThrow(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 5, v => v < 10));
            Assert.ThrowsExact <AssertionException>(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 4, v => v < 10));
            Assert.ThrowsExact <AssertionException>(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 6, v => v < 10));
            Assert.ThrowsExact <AssertionException>(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 5, v => v > 10));
            Assert.ThrowsExact <AssertionException>(() => Assert.Exactly(new int[] { 1, 2, 3, 4, 5 }, 5, v => v == 1));
        }
        public void CountElement()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Count(null as int[], 1, 1));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.Count("ABC", 1, 'c', null as IEqualityComparer <char>));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Count(new int[] { }, 1, 1));
            Assert.ThrowsExact <ArgumentException>(() => Assert.Count(new int[] { 0 }, -1, 0));

            Assert.DoesNotThrow(() => Assert.Count(new int[] { 1, 2, 3, 4, 5 }, 1, 1));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count(new int[] { 1, 4, 3, 4, 5 }, 2, 3));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count(new int[] { 1, 4, 3, 4, 5 }, 3, 4));
            Assert.DoesNotThrow(() => Assert.Count("ABC", 1, 'c', new CharCaseInvariantComparer()));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count("ABC", 2, 'c', new CharCaseInvariantComparer()));
            Assert.ThrowsExact <AssertionException>(() => Assert.Count("ABC", 0, 'c', new CharCaseInvariantComparer()));
        }
        public void IsNotType()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotType <string>(null));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotType <int>(1));
            Assert.DoesNotThrow(() => Assert.IsNotType <int?>(1));
            Assert.DoesNotThrow(() => Assert.IsNotType <int>(1L));
            Assert.DoesNotThrow(() => Assert.IsNotType <int>("hello"));

            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotType(null, typeof(string)));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotType("hello", null));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotType(1, typeof(int)));
            Assert.DoesNotThrow(() => Assert.IsNotType(1, typeof(int?)));
            Assert.DoesNotThrow(() => Assert.IsNotType(1L, typeof(int)));
            Assert.DoesNotThrow(() => Assert.IsNotType("hello", typeof(int)));
        }
        public void IsNotAssignableFromType()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotAssignableFromType <string>(null));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotAssignableFromType <int>(1));
            Assert.DoesNotThrow(() => Assert.IsNotAssignableFromType <long>(1));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotAssignableFromType <int>(new int?(1)));
            Assert.DoesNotThrow(() => Assert.IsNotAssignableFromType <int>("hello"));

            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotAssignableFromType(null, typeof(string)));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotAssignableFromType("hello", null));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotAssignableFromType(1, typeof(int)));
            Assert.DoesNotThrow(() => Assert.IsNotAssignableFromType(1, typeof(long)));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotAssignableFromType(new int?(1), typeof(int)));
            Assert.DoesNotThrow(() => Assert.IsNotAssignableFromType("hello", typeof(int)));
        }
        public void EndsWith()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.EndsWith(null, new int[0]));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.EndsWith(new int[0], null));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.EndsWith("abcd", "abc", null as IEqualityComparer <char>));
            Assert.ThrowsExact <ArgumentException>(() => Assert.EndsWith(new int[0], new int[1]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.EndsWith(new int[1], new int[0]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.EndsWith(new int[1], new int[2]));

            Assert.DoesNotThrow(() => Assert.EndsWith("hello", "llo"));
            Assert.DoesNotThrow(() => Assert.EndsWith(new[] { 1, 2, 3, 4 }, new[] { 3, 4 }));
            Assert.ThrowsExact <AssertionException>(() => Assert.EndsWith("hello", "kko"));
            Assert.ThrowsExact <AssertionException>(() => Assert.EndsWith(new[] { 1, 2, 3, 4 }, new[] { 2, 3 }));
            Assert.DoesNotThrow(() => Assert.EndsWith("hello", "LLO", new CharCaseInvariantComparer()));
            Assert.ThrowsExact <AssertionException>(() => Assert.EndsWith("hello", "KKO", new CharCaseInvariantComparer()));
        }
        public void InRangeEqual()
        {
            int minValue = 1;
            int maxValue = 10;

            Assert.ThrowsExact <ArgumentNullException>(() => Assert.InRangeEqual <string>(null, "z", "z"));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.InRangeEqual <string>("a", null, "z"));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.InRangeEqual <string>("a", "z", null));
            Assert.DoesNotThrow(() => Assert.InRangeEqual(2, minValue, maxValue));
            Assert.DoesNotThrow(() => Assert.InRangeEqual(minValue, minValue, maxValue));
            Assert.DoesNotThrow(() => Assert.InRangeEqual(maxValue, minValue, maxValue));
            Assert.ThrowsExact <AssertionException>(() => Assert.InRangeEqual(minValue - 5, minValue, maxValue));
            Assert.DoesNotThrow(() => Assert.InRangeEqual(minValue + 5, minValue, maxValue));
            Assert.DoesNotThrow(() => Assert.InRangeEqual(maxValue - 5, minValue, maxValue));
            Assert.ThrowsExact <AssertionException>(() => Assert.InRangeEqual(maxValue + 5, minValue, maxValue));
        }
        public void StartsWith()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.StartsWith(null, new int[0]));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.StartsWith(new int[0], null));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.StartsWith("abcd", "abc", null as IEqualityComparer <char>));
            Assert.ThrowsExact <ArgumentException>(() => Assert.StartsWith(new int[0], new int[1]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.StartsWith(new int[1], new int[0]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.StartsWith(new int[1], new int[2]));

            Assert.DoesNotThrow(() => Assert.StartsWith("hello", "hel"));
            Assert.DoesNotThrow(() => Assert.StartsWith(new[] { 1, 2, 3, 4 }, new[] { 1, 2 }));
            Assert.ThrowsExact <AssertionException>(() => Assert.StartsWith("hello", "jel"));
            Assert.ThrowsExact <AssertionException>(() => Assert.StartsWith(new[] { 1, 2, 3, 4 }, new[] { 2, 3 }));
            Assert.DoesNotThrow(() => Assert.StartsWith("hello", "HEL", new CharCaseInvariantComparer()));
            Assert.ThrowsExact <AssertionException>(() => Assert.StartsWith("hello", "JEL", new CharCaseInvariantComparer()));
        }
        public void IsNotStrictSubsetOf()
        {
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotStrictSubsetOf(null, new int[0]));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotStrictSubsetOf(new int[0], null));
            Assert.ThrowsExact <ArgumentNullException>(() => Assert.IsNotStrictSubsetOf("abcd", "abc", null as IEqualityComparer <char>));
            Assert.ThrowsExact <ArgumentException>(() => Assert.IsNotStrictSubsetOf(new int[0], new int[1]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.IsNotStrictSubsetOf(new int[1], new int[0]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.IsNotStrictSubsetOf(new int[1], new int[2]));
            Assert.ThrowsExact <ArgumentException>(() => Assert.IsNotStrictSubsetOf(new[] { 1 }, new[] { 1 }));

            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotStrictSubsetOf("Musky", "usk"));
            Assert.DoesNotThrow(() => Assert.IsNotStrictSubsetOf("Musky", "elk"));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotStrictSubsetOf(new[] { 1, 2, 3, 4, 5 }, new[] { 1, 2, 3 }));
            Assert.ThrowsExact <ArgumentException>(() => Assert.IsNotStrictSubsetOf(new[] { 1, 2, 3, 4, 5 }, new[] { 1, 2, 3, 4, 5 }));
            Assert.DoesNotThrow(() => Assert.IsNotStrictSubsetOf(new[] { 1, 2, 3, 4, 5 }, new[] { 1, 2, 3, 6 }));
            Assert.ThrowsExact <AssertionException>(() => Assert.IsNotStrictSubsetOf("Musky", "musk", new CharCaseInvariantComparer()));
            Assert.DoesNotThrow(() => Assert.IsNotStrictSubsetOf("Musky", "abc", new CharCaseInvariantComparer()));
        }