C# NUnit.Framework类代码示例

 public void Detect_multiple_anagrams()
 {
     var detector = new Anagram("master");
     var words = new[] { "stream", "pigeon", "maters" };
     var results = new[] { "maters", "stream" };
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

        public void ItOnlyReturnsTriggeredBundles()
        {
            var collection = new TriggerCollection();

            var bundles = new[]
            {
                new TriggerBundle(TriggerTestHelpers.StaticTrigger(true)),
                new TriggerBundle(TriggerTestHelpers.StaticTrigger(false)),
                new TriggerBundle(TriggerTestHelpers.StaticTrigger(true)),
                new TriggerBundle(TriggerTestHelpers.StaticTrigger(false)),
                new TriggerBundle(TriggerTestHelpers.StaticTrigger(false))
            };

            var expected = new[]
            {
                bundles[0],
                bundles[2],
            };

            foreach(var bundle in bundles)
            {
                collection.Add(bundle);
            }

            var actual = collection.Check();

            CollectionAssert.AreEqual(expected, actual);
        }

        public void ShouldInsertPeoples()
        {
            // Given
            var db = new DataBaseMicrosoft(DataBasesTypes.MicrosoftAccess, TestHelper.CreateTempFile());
            var peoples = new[]
            {
                new People("Акакий", "Программист"),
                new People("Генка", "Плотник")
            };
            var expected = new[]
            {
                new People("Иванов Иван", "Плотник"),
                new People("Князь Владимир", "Программист"),
                new People("Петров Петр", "Плотник"),
                new People("Клинт Бартон", "Программист"),
                new People("Акакий", "Программист"),
                new People("Генка", "Плотник")
            };

            // When
            foreach (var people in peoples)
            {
                db.ExecuteCommand(Parameters.Insert, people);
            }
            var actual = db.GetElements<People>();
            TestHelper.DeleteTemp();

            // Then
            Assert.AreEqual(expected.Length, actual.Length);
            Assert.IsInstanceOf<People>(actual[0]);
            CollectionAssert.AreEqual(expected, actual);
        }

 public void Should_Return_False_For_PropertyInfo_Objects_With_Different_Names()
 {
     var type = new { Prop1 = 10, Prop2 = 20 }.GetType();
       var propData1 = new PropertyData(type.GetProperties()[0]);
       var propData2 = new PropertyData(type.GetProperties()[1]);
       Assert.IsFalse(propData1.Equals(propData2));
 }

        public void Can_campaignTemplateContent()
        {
            var args = new { cid = "9349a04e77" };
            var templateContentResponse = tree.Do(x => x.Campaign.campaignTemplateContent(args));

            Assert.True(templateContentResponse.Success);
        }

 public void MergeSortTestWithNegativeNumbers()
 {
     var input = new[] { 2, 3, 1, -7, 4, 9 };
     var expected = new[] { -7, 1, 2, 3, 4, 9 };
     SortingProblems.MergeSort(input);
     CollectionAssert.AreEqual(expected, input);
 }

        public void Cmasp_Do()
        {
            var addr = Address.SegPtr(0x0C20, 0);
            var proc = new Procedure("foo", null);
            var progaddr = new ProgramAddress(program, addr);
            var dc = mr.Stub<IDecompiler>();
            var dcSvc = mr.Stub<IDecompilerService>();
            var brSvc = mr.Stub<IProjectBrowserService>();
            dcSvc.Decompiler = dc;
            sc.AddService<IDecompilerService>(dcSvc);
            sc.AddService<IProjectBrowserService>(brSvc);
            sc.AddService<IDecompilerShellUiService>(new FakeShellUiService());
            dc.Expect(d => d.ScanProcedure(progaddr)).IgnoreArguments().Return(proc);
            brSvc.Expect(b => b.Reload());
            mr.ReplayAll();

            var locations = new[] { new ProgramAddress(program, addr) };
            var cmd = new Cmd_MarkProcedures(sc, locations);
            cmd.DoIt();

            mr.VerifyAll();
            Assert.AreEqual(1, program.User.Procedures.Count);
            var uproc = program.User.Procedures.Values[0];
            Assert.AreEqual("0C20:0000", uproc.Address);
        }

 public void Anagrams_are_case_insensitive()
 {
     var detector = new Anagram("Orchestra");
     var words = new[] { "cashregister", "Carthorse", "radishes" };
     var results = new[] { "Carthorse" };
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void No_matches()
 {
     var detector = new Anagram("diaper");
     var words = new[] { "hello", "world", "zombies", "pants" };
     var results = new string[0];
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void Eliminate_anagram_subsets()
 {
     var detector = new Anagram("good");
     var words = new[] { "dog", "goody" };
     var results = new string[0];
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void Identical_word_is_not_anagram()
 {
     var detector = new Anagram("corn");
     var words = new[] { "corn", "dark", "Corn", "rank", "CORN", "cron", "park" };
     var results = new[] { "cron" };
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void Eliminate_anagrams_with_same_checksum()
 {
     var detector = new Anagram("mass");
     var words = new[] { "last" };
     var results = new string[0];
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void Does_not_confuse_different_duplicates()
 {
     var detector = new Anagram("galea");
     var words = new[] { "eagle" };
     var results = new string[0];
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void Detect_simple_anagram()
 {
     var detector = new Anagram("ant");
     var words = new[] { "tan", "stand", "at" };
     var results = new[] { "tan" };
     Assert.That(detector.Match(words), Is.EquivalentTo(results));
 }

 public void InsertionSortTestWithNegativeNumbers()
 {
     var input = new[] { 2, 3, 1, -7, 4, 9 };
     var expected = new[] { -7, 1, 2, 3, 4, 9 };
     int[] actual = SortingProblems.InsertionSort(input);
     CollectionAssert.AreEqual(expected, actual);
 }