Example #1
0
        private static void Main()
        {
            List <string> dictionary = ReadDictionary();

            Console.WriteLine();
            var(start, end) = GetInput(dictionary);
            Console.WriteLine();

            dictionary = dictionary.Where(word => word.Length == start.Length).ToList();
            if (!WordLadderSolver.TryFindLadder(start, end, dictionary, out var ladder))
            {
                Console.WriteLine($"Could not find word ladder for the given words {start} to {end}");
                Environment.Exit(1);
            }

            Console.Write("Ladder: ");
            for (var i = 0; i < ladder.Count; i++)
            {
                var arrow = string.Empty;
                if (i + 1 != ladder.Count)
                {
                    arrow = " -> ";
                }
                Console.Write(ladder[i] + arrow);
            }
            Console.WriteLine();
            Console.WriteLine();
        }
        public void TryFindLadder_WhenGivenTwoWordsOfDifferentLength_Throws()
        {
            //arrange

            //act + assert
            var exception = Assert.Throws <WordLengthException>(() => WordLadderSolver.TryFindLadder(
                                                                    "test",
                                                                    "tests",
                                                                    _dictionary,
                                                                    out var ladder));
        }
        public void TryFindLadder_WhenEndWordDoesExistInDictionary_Throws()
        {
            //arrange
            const string nonExistantWord = "asd";

            //act + assert
            var exception = Assert.Throws <WordDoesNotExistException>(() => WordLadderSolver.TryFindLadder(
                                                                          START_WORD,
                                                                          nonExistantWord,
                                                                          _dictionary,
                                                                          out var ladder));
        }
        public void TryFindLadder_WhenGivenANullEndingWord_Throws()
        {
            //arrange

            //act
            var exception = Assert.Throws <ArgumentException>(() => WordLadderSolver.TryFindLadder(
                                                                  START_WORD,
                                                                  null,
                                                                  new List <string>(),
                                                                  out var ladder));

            Assert.Equal(END_WORD_PARAM_NAME, exception.ParamName);
        }
        public void TryFindLadder_WhenGivenAnNullDictionary_Throws()
        {
            //arrange

            //act
            var exception = Assert.Throws <ArgumentException>(() => WordLadderSolver.TryFindLadder(
                                                                  START_WORD,
                                                                  END_WORD,
                                                                  null,
                                                                  out var ladder));

            //assert
            Assert.Equal(DICTIONARY_PARAM_NAME, exception.ParamName);
        }
        public void TryFindLadder_WhenGivenAnEmptyStringAsBeginningWord_Throws()
        {
            //arrange

            //act
            var exception = Assert.Throws <ArgumentException>(() => WordLadderSolver.TryFindLadder(
                                                                  string.Empty,
                                                                  END_WORD,
                                                                  new List <string>(),
                                                                  out var ladder));

            //assert
            Assert.Equal(START_WORD_PARAM_NAME, exception.ParamName);
        }
        public void TryFindLadder_WhenGivenAValidStartAndEndWord_ReturnsALadder(string startWord, string endWord, string[] expected)
        {
            //arrange

            //act
            var result = WordLadderSolver.TryFindLadder(
                startWord,
                endWord,
                _dictionary,
                out var ladder);

            //assert
            Assert.True(result);
            Assert.Equal(expected, ladder);
        }
        public void TryFindLadder_WhenGivenValidInput_AndCannotFindALadder_ReturnsFalse()
        {
            //arrange
            const string startWord = "ham";

            //act
            var result = WordLadderSolver.TryFindLadder(
                startWord,
                END_WORD.ToLower(),
                _dictionary,
                out var ladder);

            //assert
            Assert.False(result);
            Assert.Equal(ladder, new List <string>());
        }
        public void TryFindLadder_WhenGivenAValidStartAndEndWord_AndTheyAreDifferentCases_ReturnsALadder()
        {
            //arrange
            var expected = new List <string>()
            {
                "cat",
                "cot",
                "cog",
                "dog"
            };

            //act
            var result = WordLadderSolver.TryFindLadder(
                START_WORD.ToUpper(),
                END_WORD.ToLower(),
                _dictionary,
                out var ladder);

            //assert
            Assert.True(result);
            Assert.Equal(expected, ladder);
        }