public void CalculatePriority_CharacterSubstitutionFrequencyIntermediate()
        {
            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 0, 0, 0, 1, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);

            Double result = testCandidateWordPriorityCalculator.CalculatePriority("read", "real", "mate", 20);

            Assert.AreEqual(0.5, result);
        }
        public void CalculatePriority_CharacterSubstitutionFrequencyMinimum()
        {
            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 0, 0, 0, 1, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);

            Double result = testCandidateWordPriorityCalculator.CalculatePriority("mall", "malt", "mate", 20);

            Assert.AreEqual(1.0, result);
        }
        public void CalculatePriority_CandidateToDestinationMatchingCharactersDifferingCounts()
        {
            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 0, 1, 0, 0, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);

            Double result = testCandidateWordPriorityCalculator.CalculatePriority("read", "lead", "toll", 20);

            Assert.AreEqual(1.0, result);
        }
        public void CalculatePriority_SourceToCandidateDistanceMaximum()
        {
            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 1, 0, 0, 0, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);

            Double result = testCandidateWordPriorityCalculator.CalculatePriority("test", "best", "mall", 1);

            Assert.AreEqual(0.05, result);
        }
        public void Constructor_AllWeights0()
        {
            ArgumentException e = Assert.ThrowsException <ArgumentException>(() =>
            {
                testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 0, 0, 0, 0, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);
            });

            StringAssert.StartsWith(e.Message, "At least one of parameters 'sourceWordToCandidateWordDistanceWeight', 'numberOfCharactersMatchingDestinationWeight', 'popularityOfChangeToCharacterWeight', and 'popularityOfCharacterChangeWeight' must be greater than 0.");
        }
        public void Constructor_MaximumSourceWordToCandidateWordDistanceLessThan1()
        {
            ArgumentException e = Assert.ThrowsException <ArgumentException>(() =>
            {
                testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(0, 1, 1, 1, 1, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);
            });

            StringAssert.StartsWith(e.Message, "Parameter 'maximumSourceWordToCandidateWordDistance' must be greater than or equal to 1.");
            Assert.AreEqual("maximumSourceWordToCandidateWordDistance", e.ParamName);
        }
        public void Constructor_PopularityOfCharacterChangeWeightLessThan0()
        {
            ArgumentException e = Assert.ThrowsException <ArgumentException>(() =>
            {
                testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 1, 0, 0, -1, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);
            });

            StringAssert.StartsWith(e.Message, "Parameter 'popularityOfCharacterChangeWeight' must be greater than or equal to 0.");
            Assert.AreEqual("popularityOfCharacterChangeWeight", e.ParamName);
        }
        public void CalculatePriority_MixedPriorityWeights()
        {
            // Overall priority should be calculated as follows (see DataStructureUtilitiesTests.PopulateAdjacentWordDataStructures() test for a list of the expected contents of 'fromCharacterFrequencies' and 'characterSubstitutionFrequencies')...
            // CalculateSourceWordToCandidateWordDistancePriority()
            //   distance = 5/20 = 0.25,  weighting = 1/10 = 0.1, weighted priority = 0.025
            // CalculateNumberOfCharactersMatchingDestinationPriority()
            //   matching characters ('bead' and 'beat') = 3/4 = 0.75, weighting = 2/10 = 0.2, weighted priority = (1 - 0.75) * 0.2 = 0.05
            // CalculatePopularityOfChangeToCharacterPriority()
            //   changeTo character = 'b', popularity = 2/4 = 0.5, weighting = 3/10 = 0.3, weighted priority = (1 - 0.5) * 0.3 = 0.15
            // CalculatePopularityOfCharacterChangePriority()
            //   character substitution = 'r' > 'b', popularity = 1/2 = 0.5, weighting = 4/10 = 0.4, weighted priority = (1 - 0.5) * 0.4 = 0.2
            // Total weighting = 0.025 + 0.05 + 0.15 + 0.2 = 0.425

            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 1, 2, 3, 4, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);

            Double result = testCandidateWordPriorityCalculator.CalculatePriority("read", "bead", "beat", 5);

            Assert.AreEqual(0.425D, Math.Round(result, 4));
        }
        public void SetUp()
        {
            mockery                          = new Mockery();
            mockStreamReader                 = mockery.NewMock <IStreamReader>();
            allWordsTrieRoot                 = new Dictionary <Char, TrieNode <Char> >();
            allWords                         = new HashSet <String>();
            fromCharacterFrequencies         = new FrequencyTable <Char>();
            characterSubstitutionFrequencies = new FrequencyTable <CharacterSubstitution>();
            List <String> testWords = new List <String>()
            {
                "read",
                "bead",
                "fail",
                "dead",
                "road",
                "reed",
                "calm",
                "real",
                "rear"
            };
            Func <String, Boolean> wordFilterFunction   = new Func <String, Boolean>((inputString) => { return(true); });
            CharacterTrieBuilder   characterTrieBuilder = new CharacterTrieBuilder();

            using (mockery.Ordered)
            {
                foreach (String currentTestWord in testWords)
                {
                    Expect.Once.On(mockStreamReader).GetProperty("EndOfStream").Will(Return.Value(false));
                    Expect.Once.On(mockStreamReader).Method("ReadLine").WithNoArguments().Will(Return.Value(currentTestWord));
                }
                Expect.Once.On(mockStreamReader).GetProperty("EndOfStream").Will(Return.Value(true));
                Expect.Once.On(mockStreamReader).Method("Dispose").WithNoArguments();
            }
            dataStructureUtilities.PopulateAdjacentWordDataStructures(mockStreamReader, characterTrieBuilder, wordFilterFunction, allWordsTrieRoot, allWords, fromCharacterFrequencies, characterSubstitutionFrequencies);
            mockery.ClearExpectation(mockStreamReader);
            testCandidateWordPriorityCalculator = new CandidateWordPriorityCalculator(20, 1, 1, 1, 1, allWordsTrieRoot, fromCharacterFrequencies, characterSubstitutionFrequencies);
        }
        public void SetUp()
        {
            CandidateWordPriorityCalculator priorityCalculator = new CandidateWordPriorityCalculator(20, 1, 1, 1, 1, new Dictionary <Char, TrieNode <Char> >(), new FrequencyTable <Char>(), new FrequencyTable <CharacterSubstitution>());

            testAdjacentWordGraphPathFinder = new AdjacentWordGraphPathFinder(priorityCalculator, new CharacterTrieUtilities(), new Dictionary <Char, TrieNode <Char> >());
        }