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);
 }

        public void Can_describe_a_field_reference()
        {
            var Foo = new {Bar = 6};

            string description = SpecDescriber.DescribeSpec(() => Foo.Bar == 42);
            description.ShouldBe("Foo.Bar should equal 42");
        }

 public void MergeSortTestHappyFlow2()
 {
     var input = new[] { 2, 5, 3 };
     var expected = new[] { 2, 3, 5 };
     SortingProblems.MergeSort(input);
     CollectionAssert.AreEqual(expected, input);
 }

        public void StartAndEndOfStringOrLine()
        {
            string input = "One thing or another\nAnd then some";

            string[] patterns = new[] {
                @"^\w+",
                @"\w+$",

                @"^\w+|\w+$",
                @"\w+$|^\w+",

                @"\w*^\w*",
                @"\w*$\w*",
                @"\w+$\w*",

                @"\A\w+",
                @"\w+\Z",
                @"\w+\z",

                @"\A\w+|\w+\Z",
            };

            RegexAssert.AreMatchesSameAsMsoft(input, patterns, AlgorithmType);

            RegexAssert.AreMatchesSameAsMsoft(input, patterns, AlgorithmType, RegexOptions.Multiline);
        }

 public void QuickSortPositiveTest()
 {
     var input = new[] { 2, 5, 3, 1 };
     var expected = new[] { 1, 2, 3, 5 };
     SortingProblems.QuickSort(input);
     CollectionAssert.AreEqual(expected, input);
 }

        public void Language_DoesProduceCorrectTokens()
        {
            string test = null;

            Func<Grammar.Token[]> testit = () =>
                new Grammar.Lexer(new StringReader(test)).ToArray();

            test = "using namespace @namespace;";

            var expected = new[] { Using, Namespace, Identifier, Semicolon, Eof };

            var result = testit();
            var resultTerminals = result.Select(r => r.Terminal).ToArray();
            
            Assert.That(resultTerminals, Is.EquivalentTo(expected));
            Assert.That(result[2], Is.AssignableFrom<IdentifierToken>());
            Assert.That((result[2] as IdentifierToken).Name, Is.EqualTo("namespace"));
            Assert.That(result[2].Lexeme, Is.EqualTo("@namespace"));
            Assert.That(result.AsLexemes(), Is.EquivalentTo(new[] { "using", "namespace", "@namespace", ";", null }));

            test = "34.3f";
            result = testit();
            Assert.That(result[0], Is.TypeOf<NumberToken>());
            var number = result[0] as NumberToken;
            Assert.That(number.GetFloatValue(), Is.EqualTo(34.3f));
            Assert.That(number.IsTypeSpecified, Is.True);
            Assert.That(number.TypeSuffix, Is.EqualTo('f'));
        }