public void EmptyTrie()
        {
            var trie = new Trie<string, string>();

            var get = trie.Values("43").SingleOrDefault();
            Assert.Null(get);
        }

        public void AddWithSameKey()
        {
            var trie = new Trie<bool>();

            trie.Add("a", false);
            trie.Add("a", true);
        }

 public void AddWords()
 {
     words = new Trie();
     CloudStorageAccount storageAccount = CloudStorageAccount.Parse(CloudConfigurationManager.GetSetting("StorageConnectionString"));
     CloudBlobClient blobClient = storageAccount.CreateCloudBlobClient();
     CloudBlobContainer container = blobClient.GetContainerReference("http://hudpoi459storage.blob.core.windows.net/hudson/");
     CloudBlockBlob blockBlob = container.GetBlockBlobReference("wikipedia.txt");
     try
     {
         using (var stream = blockBlob.OpenRead())
         {
             using (StreamReader sr = new StreamReader(stream))
             {
                 string line;
                 while ((line = sr.ReadLine()) != null)
                 {
                     words.Insert(line);
                 }
             }
         }
     }
     catch (OutOfMemoryException)
     {
         GC.Collect();
     }
 }

        public void PrefixMatchTest()
        {
            string s = @"
                In computer science, a trie, or prefix tree,
                is an ordered tree data structure that is used to
                store an associative array where the keys are strings.
                Unlike a binary search tree, no node in the tree
                stores the key associated with that node;
                instead, its position in the tree shows what key
                it is associated with. All the descendants
                of any one node have a common prefix of the string
                associated with that node, and the root is associated
                with the empty string. Values are normally not associated
                with every node, only with leaves and some inner nodes
                that happen to correspond to keys of interest.
            ";

            Trie<char, string> wordIndex = new Trie<char, string>(new LettersDomain());
            foreach (string word in s.Replace("\r", "").Replace("\n", " ").Replace("\t", "").Split(' ', ',', ';', '.'))
            {
                if (word.Length > 0)
                {
                    wordIndex.Add(word, word);
                }
            }

            ITrieEnumerator<char, string> matches = wordIndex.PrefixMatch("p");
            while (matches.MoveNext())
            {
                Console.WriteLine(matches.Current.Value);
            }
        }

 public EnemyInputManager(List<String> texts, Game game)
 {
     trie = new Trie<Enemy>();
     this.texts = texts;
     this.game = game;
     currentlyMatched = new List<Enemy>();
 }

        public static void Main()
        {
            Trie<int> trie = new Trie<int>();

            using (StreamReader reader = new StreamReader("../../test.txt"))
            {
                while (!reader.EndOfStream)
                {
                    string[] line = reader.ReadLine().Split(new char[] { ' ', '.', ',', '!', '?', ':', ';', '-' }, StringSplitOptions.RemoveEmptyEntries).ToArray();

                    foreach (var word in line)
                    {
                        if (!trie.ContainsKey(word))
                        {
                            trie.Add(word, 1);
                        }
                        else
                        {
                            trie[word]++;
                        }
                    }
                }
            }

            trie.Matcher.Next("eros");
            Console.WriteLine(trie.Matcher.GetExactMatch());
        }

        public void Add_ItemExists_Throws()
        {
            Trie<string, char, int> trie = new Trie<string, char, int>();

            trie.Add("key", 5);
            trie.Add("key", 6);
        }

        static void Main(string[] args)
        {
            Stopwatch _s = new Stopwatch();

            _s.Start();

            /* */
            //Trie<byte[]> _trie = new Trie<byte[]>();
            Trie<string> _trie = new Trie<string>();
            for (int i = 0; i < 1000000; i++)
            {
                //byte[] bkey = Encoding.ASCII.GetBytes("root/sub/key" + i);
                //byte[] bvalue = Encoding.ASCII.GetBytes("test_" + i);
                _trie.Add("root/sub/key" + i, "test_" + i);
            }

            //var f=_trie.Find("root/sub/key999090");
            var g = _trie.FindAll("root/sub/key0");
            // SPEED ~ 1700 msec
            //*/

            /* /
            Trie2 _trie2 = new Trie2();
            for (int i = 0; i < 1000000; i++)
            {
                _trie2.AddNodeForWord("root/sub/key" + i);
            }
            //*/

            _s.Stop();

            Console.WriteLine("hj");
            Console.ReadKey();
        }

        public void TrieTests_EnumerateInOrder2()
        {
            Trie<char> trie = new Trie<char>();

            List<string> items = new List<string>();

            Random r = new Random();
            for (int i = 0; i < 100000; i++)
            {
                char[] word = new char[r.Next(10) + 1];

                for (int j = 0; j < word.Length; j++)
                {
                    word[j] = (char)(97 + r.Next(26));
                }

                string sword = new string(word);

                items.Add(sword);

                trie.Insert(sword);
            }

            items.Sort();

            var actualOrder = trie.EnumerateInOrder().Select(sequence => new string(sequence.ToArray())).ToList();

            Assert.IsTrue(items.Except(actualOrder).Count() == 0);
            Assert.IsTrue(actualOrder.Except(items).Count() == 0);
        }

        public void Trie_Clone_should_work()
        {
            var trie = new Trie<char, int>();
              trie.SetValue("foo", 42);
              trie.SetValue("foobar", 13);
              trie.SetValue("fizban", 53);
              trie.SetValue("fizbang", 12);

              var cloneTrie = trie.Clone();
              cloneTrie.SetValue("fip", 17);

              int value;

              trie.TryGetValue("foo", out value).Should().BeTrue();
              value.Should().Be(42);
              trie.TryGetValue("foobar", out value).Should().BeTrue();
              value.Should().Be(13);
              trie.TryGetValue("fizban", out value).Should().BeTrue();
              value.Should().Be(53);
              trie.TryGetValue("fizbang", out value).Should().BeTrue();
              value.Should().Be(12);
              trie.TryGetValue("fip", out value).Should().BeFalse();

              cloneTrie.TryGetValue("foo", out value).Should().BeTrue();
              value.Should().Be(42);
              cloneTrie.TryGetValue("foobar", out value).Should().BeTrue();
              value.Should().Be(13);
              cloneTrie.TryGetValue("fizban", out value).Should().BeTrue();
              value.Should().Be(53);
              cloneTrie.TryGetValue("fizbang", out value).Should().BeTrue();
              value.Should().Be(12);
              cloneTrie.TryGetValue("fip", out value).Should().BeTrue();
              value.Should().Be(17);
        }

    public static void Main()
    {
        string inputText;
        StreamReader reader = new StreamReader("test.txt");

        using (reader)
        {
            inputText = reader.ReadToEnd().ToLower();
        }

        var matches = Regex.Matches(inputText, @"[a-zA-Z]+");
        HashSet<string> uniqueWords = new HashSet<string>();
        var trie = new Trie();

        for (int i = 0; i < matches.Count; i++)
        {
            uniqueWords.Add(matches[i].ToString());
            trie.Add(matches[i].ToString());
        }

        foreach (var word in uniqueWords)
        {
            Console.WriteLine("{0} -> {1} times", word, trie.GetWordOccurance(word));
        }
    }

 //    Start a pattern match at the beginning with one object.
 internal PatternMatcher(ProseRuntime runtime)
 {
     this.runtime = runtime;
     patternTrie = runtime.GlobalScope.PatternTree;
     state = MatcherState.MATCHING_OBJECT;
     currNode = patternTrie.Root;
 }

        static void Main(string[] args)
        {
            Trie trie = new Trie();
            Dictionary<string, int> dict = new Dictionary<string, int>();
            Stopwatch sw = new Stopwatch();

            sw.Start();
            List<string> wordsFromText = GetWordsFromText();
            sw.Stop();
            Console.WriteLine("Word extraction finished in {0}", sw.Elapsed);

            List<string> wordsToSearch = new List<string>();
            int numberOfWords = 100;

            int len = numberOfWords < wordsFromText.Count ? numberOfWords : wordsFromText.Count;

            for (int i = 0; i < len; i++)
			{
                wordsToSearch.Add(wordsFromText[i]);			 
			}

            AddWordsUsingTrie(trie, wordsFromText, sw);
            AddWordsUsingDict(dict, wordsFromText, sw);

            FindWordsUsingTrie(trie, wordsToSearch, sw);
            FindWordsUsingDict(dict, wordsToSearch, sw);
        }

    static void Main()
    {
        Trie<string> trie = new Trie<string>();
        StreamReader reader = new StreamReader(@"../../../text.txt");
        using (reader)
        {
            string text = reader.ReadToEnd();

            char[] separators = { ' ', '.', '!', '-', '?', '_' };
            string[] array = text.Split(separators, StringSplitOptions.RemoveEmptyEntries);

            for (int i = 0; i < array.Length; i++)
            {
                trie.Put(array[i], i.ToString());
            }

            string word = "Conan";
            for (int i = 0; i < word.Length; i++)
            {

            }
            foreach (var item in trie.Matcher.GetPrefixMatches())
            {
                Console.WriteLine(item);
            }
            Console.WriteLine(trie.Matcher.GetExactMatch());
        }
    }

        private static Trie<int> ParseFile(string filename)
        {
            Trie<int> trie = new Trie<int>();

            Console.WriteLine("Reading file and loading content in trie:");

            using (StreamReader reader = new StreamReader(filename))
            {
                while (!reader.EndOfStream)
                {
                    reader
                        .ReadLine()
                        .Split(' ', '.', ',', '?', '!', ':')
                        .ToList()
                        .ForEach(word =>
                        {
                            if (!trie.ContainsKey(word))
                            {
                                trie.Add(word, 1);
                            }
                            else
                            {
                                trie[word] += 1;
                            }
                        });
                }
            }

            Console.WriteLine("File read and loaded into trie");

            return trie;
        }

 private static Trie<string> ParseTree(IEnumerable<string> p)
 {
     var trie = new Trie<string>();
     foreach (var word in p)
         trie.Add(word, word);
     return trie;
 }

        public void TrieOnce()
        {
            var trie = new Trie<string, string>();
            trie.Add("123", "hello");

            var get = trie.Values("123").Single();
            Assert.Equal("hello", get);
        }

        public void NoKey()
        {
            var trie = new Trie<string, string>();
            trie.Add("123", "hello");

            var get = trie.Values("43").SingleOrDefault();
            Assert.Null(get);
        }

        public void Add_KVP_NullItemIsAdded()
        {
            Trie<string, char, object> trie = new Trie<string, char, object>();

            trie.Add(new KeyValuePair<string, object>("key", null));

            Assert.AreEqual(1, trie.Count);
            Assert.AreEqual(null, trie["key"]);
        }

        public void Trie_TryGetValue_should_work()
        {
            var trie = new Trie<char, int>();
              trie.SetValue("foo", 42);

              int value;
              trie.TryGetValue("foo", out value).Should().BeTrue();
              value.Should().Be(42);
        }