public MakeSureEmptyLinesAreHandled(){(line 31)
			     var converter = new HighlightSearchKey();(line 34)
			     var sb = new StringBuilder();(line 35)
			     for(int i = 0; i < 10; i ++)(line 36)
			         sb.AppendLine("abc");(line 38)
			         sb.AppendLine();(line 39)
			     var info = new InternalHighlightRawInfo(sb.ToString(),1);(line 41)
			     var lines = Span converter.Convert(info,null,null,null).Inlines.ToArray();(line 42)
			     var n = Environment.NewLine;(line 43)
			}

 
			public HandleTextWithHeadingAndTailingEmptyLines(){(line 46)
			     var converter = new HighlightSearchKey();(line 49)
			     var sb = new StringBuilder();(line 50)
			     sb.AppendLine();(line 51)
			     sb.AppendLine();(line 52)
			     for(int i = 0; i < 10; i ++)(line 53)
			         sb.AppendLine("abc");(line 55)
			         sb.AppendLine();(line 56)
			     sb.AppendLine();(line 58)
			     sb.AppendLine();(line 59)
			     var info = new InternalHighlightRawInfo(sb.ToString(),1);(line 60)
			     converter.Convert(info,null,null,null);(line 61)
			}

 
			public HighlightedWordAtBeginningTest(){(line 64)
			     var text = "|~S~|add|~E~|{\r\n}";(line 67)
			     var info = new InternalHighlightRawInfo(text,1);(line 68)
			     var converter = new HighlightSearchKey();(line 69)
			     converter.Convert(info,null,null,null);(line 70)
			}

 
			public RemoveEscapesFromQuery(){(line 15)
			     SearchViewControl.GetKeys("\"\"Graph\"\"").First().Equals("\"Graph\"");(line 18)
			}

 
			public ExpandThreeLetters(){(line 29)
			     var queries = expander.GetExpandedQueries("abc");(line 32)
			     Assert.IsNotNull(queries);(line 33)
			     Assert.IsTrue(queries.Any());(line 34)
			     queries = expander.GetExpandedQueries("bcd");(line 35)
			     Assert.IsNotNull(queries);(line 36)
			     Assert.IsTrue(queries.Any());(line 37)
			     queries = expander.GetExpandedQueries("def");(line 38)
			     Assert.IsNotNull(queries);(line 39)
			     Assert.IsTrue(queries.Any());(line 40)
			}

 
			public ExpandTwoLetters(){(line 43)
			     var queries = expander.GetExpandedQueries("ab");(line 46)
			     Assert.IsTrue(queries.Any());(line 47)
			     queries = expander.GetExpandedQueries("em");(line 48)
			     Assert.IsTrue(queries.Any());(line 49)
			}

 
			public ExpandMoreLetters(){(line 52)
			     var queries = expander.GetExpandedQueries("abfdsafdsafdc");(line 55)
			     Assert.IsNotNull(queries);(line 56)
			     queries = expander.GetExpandedQueries("bcfdasfdsad");(line 57)
			     Assert.IsNotNull(queries);(line 58)
			     queries = expander.GetExpandedQueries("defdasfdsaf");(line 59)
			     Assert.IsNotNull(queries);(line 60)
			}

 
			public SameLocalDictionaryWordPairAlwaysExist(){(line 37)
			     AssertWordPairExist("sando","sando");(line 40)
			     AssertWordPairExist("abb","abb");(line 41)
			     AssertWordPairExist("test","test");(line 42)
			}

 
			public SameNonLocalDictionaryWordNeverExist(){(line 45)
			     AssertWordPairNonExist("animal","animal");(line 48)
			     AssertWordPairNonExist("bush","bush");(line 49)
			     AssertWordPairNonExist("pinkcolor","pinkcolor");(line 50)
			}

 
			public DifferentWordPairsThatExist(){(line 53)
			     AssertWordPairExist("method","name");(line 56)
			     AssertWordPairExist("assert","true");(line 57)
			     AssertWordPairExist("search","result");(line 58)
			     AssertWordPairExist("assert","null");(line 59)
			     AssertWordPairExist("sando","search");(line 60)
			     AssertWordPairExist("directory","update");(line 61)
			     AssertWordPairExist("configuration","results");(line 62)
			}

 
			public DifferentWordPairsThatDoesNotExist(){(line 65)
			     AssertWordPairNonExist("confidence","apple");(line 68)
			     AssertWordPairNonExist("confidence","lackof");(line 69)
			     AssertWordPairNonExist("confidence","configuration");(line 70)
			     AssertWordPairNonExist("configuration","nomad");(line 71)
			}

 
			public AssertCanGetWordsAndCount(){(line 74)
			     var dic = matrix.GetAllWordsAndCount();(line 77)
			     Assert.IsNotNull(dic);(line 78)
			     Assert.IsTrue(dic.Any());(line 79)
			}

 
			public ReformWordWithoutContext(){(line 57)
			     Assert.IsTrue(! GetReformedWord("",new).Any());(line 60)
			     Assert.IsTrue(! GetReformedWord("sando",new string).Any());(line 61)
			     Assert.IsTrue(! GetReformedWord("abb",new string).Any());(line 62)
			}

 
			public ReformWordWithOneNeighborredWord(){(line 65)
			     AssertReformProperly("somewiredwodnotindictionary",new string);(line 68)
			     AssertReformProperly("somewiredwodnotindictionary",new string);(line 69)
			     AssertNotReformed("sando",new string);(line 70)
			     AssertNotReformed("sando",new string);(line 71)
			}

 
			public AddWordsSeveralTimes(){(line 33)
			     int listLength = 20;(line 36)
			     int coocurrenceCount = 3;(line 37)
			     var words = GenerateRandomWordList(listLength);(line 38)
			     for(int i = 0; i < coocurrenceCount; i ++)(line 39)
			         matrix.HandleCoOcurrentWordsSync(words);(line 41)
			     for(int i = 0; i < listLength - 1; i ++)(line 43)
			         var word1 = words.ElementAt(i);(line 45)
			         var word2 = words.ElementAt(i + 1);(line 46)
			         var count = matrix.GetCoOccurrenceCount(word1,word2);(line 47)
			         Assert.IsTrue(count > 0);(line 48)
			}

 
			public ConfirmAssumptionAboutStringComparisons(){(line 52)
			     Assert.IsTrue("abc".CompareTo("") > 0);(line 55)
			     Assert.IsTrue("a".CompareTo("") > 0);(line 56)
			     Assert.IsTrue("zzzzzzzz".CompareTo("") > 0);(line 57)
			}

 
			public QueryWordsDoesNotDependOnOrder(){(line 60)
			     matrix.HandleCoOcurrentWordsSync(new string);(line 63)
			     Assert.IsTrue(matrix.GetCoOccurrenceCount("word1","word2") == 1);(line 64)
			     Assert.IsTrue(matrix.GetCoOccurrenceCount("word2","word1") == 1);(line 65)
			}

 
			public PerformanceTest(){(line 68)
			     var stopwatch = new Stopwatch();(line 71)
			     var words = GenerateRandomWordList(100);(line 72)
			     stopwatch.Start();(line 73)
			     matrix.HandleCoOcurrentWordsSync(words);(line 74)
			     stopwatch.Stop();(line 75)
			     long time = stopwatch.ElapsedMilliseconds;(line 76)
			     Assert.IsTrue(time < 1000);(line 77)
			}

 
			public ReformWiredTerms(){(line 89)
			     reformer.ReformTermsSynchronously(new string);(line 92)
			}

 
			public ReformOneTermInDictionary(){(line 95)
			     AssertNotReformed(new string);(line 98)
			     AssertNotReformed(new string);(line 99)
			     AssertNotReformed(new string);(line 100)
			     AssertNotReformed(new string);(line 101)
			     AssertNotReformed(new string);(line 102)
			     AssertNotReformed(new string);(line 103)
			     AssertNotReformed(new string);(line 104)
			}

 
			public ReformOneTermNotInDictionary(){(line 107)
			     AssertReformed(new string,new int,new string);(line 110)
			     AssertReformed(new string,new int,new string);(line 111)
			     AssertReformed(new string,new int,new string);(line 112)
			     AssertReformed(new string,new int,new string);(line 114)
			     AssertReformed(new string,new int,new string);(line 115)
			     AssertReformed(new string,new int,new string);(line 116)
			     AssertReformed(new string,new int,new string);(line 117)
			     AssertReformed(new string,new int,new string);(line 118)
			}

 
			public NotReformingWordWhoseStemmingIsInDictionary(){(line 122)
			     AssertNotReformed(new string);(line 125)
			     AssertNotReformed(new string);(line 126)
			     AssertNotReformed(new string);(line 127)
			     AssertNotReformed(new string);(line 128)
			     AssertNotReformed(new string);(line 129)
			     AssertNotReformed(new string);(line 130)
			     AssertNotReformed(new string);(line 131)
			}

 
			public MakeSureLeavingQuotedTermUntouched(){(line 134)
			     AssertNotReformed(new string);(line 137)
			     AssertNotReformed(new string);(line 138)
			     AssertNotReformed(new string);(line 139)
			     AssertNotReformed(new string);(line 140)
			     AssertNotReformed(new string);(line 141)
			}

 
			public TermChangeTypeTestForNonWord(){(line 145)
			     string word = "addi";(line 148)
			     var newQueries = reformer.ReformTermsSynchronously(new string);(line 149)
			     AssertOriginalTerm(newQueries,word);(line 150)
			     var q1 = newQueries.Where();(line 151)
			     var q2 = newQueries.Where();(line 153)
			     var q3 = newQueries.Where();(line 155)
			     Assert.IsTrue(q1.Any());(line 157)
			     Assert.IsTrue(! q2.Any());(line 158)
			     Assert.IsTrue(! q3.Any());(line 159)
			}

 
			public TermChangeTypeTestForWordExistingInLocalDictionary(){(line 163)
			     string word = "add";(line 166)
			     var newQueries = reformer.ReformTermsSynchronously(new string);(line 167)
			     AssertOriginalTerm(newQueries,word);(line 168)
			     var q1 = newQueries.Where();(line 169)
			     var q2 = newQueries.Where();(line 171)
			     var q3 = newQueries.Where();(line 173)
			     Assert.IsTrue(! q1.Any());(line 176)
			     Assert.IsTrue(! q2.Any());(line 177)
			     Assert.IsTrue(! q3.Any());(line 178)
			}

 
			public TermChangeTypeTestForWordNotExistingInLocalDictionary(){(line 181)
			     string word = "instantiate";(line 184)
			     var newQueries = reformer.ReformTermsSynchronously(new string);(line 185)
			     AssertOriginalTerm(newQueries,word);(line 186)
			     var q1 = newQueries.Where();(line 187)
			     var q2 = newQueries.Where();(line 189)
			     var q3 = newQueries.Where();(line 191)
			     Assert.IsTrue(q1.Any());(line 193)
			     Assert.IsTrue(q2.Any());(line 194)
			     Assert.IsTrue(! q3.Any());(line 195)
			     var word1 = q1.First().ReformedWords.First().NewTerm;(line 196)
			     var word2 = q2.First().ReformedWords.First().NewTerm;(line 197)
			     Assert.IsTrue(! word1.Equals(word2));(line 198)
			}

 
			public TermChangeTypeForTermsInGeneralEnglishDictionary(){(line 201)
			     string word = "principal";(line 204)
			     var newQueries = reformer.ReformTermsSynchronously(new string);(line 205)
			     AssertOriginalTerm(newQueries,word);(line 206)
			     var q1 = newQueries.Where();(line 207)
			     var q2 = newQueries.Where();(line 209)
			     var q3 = newQueries.Where();(line 211)
			     Assert.IsTrue(q1.Any());(line 213)
			     Assert.IsTrue(! q2.Any());(line 214)
			     Assert.IsTrue(q3.Any());(line 215)
			}

 
			public TestingTermsThatNeverOccurTogetherAreFiltered(){(line 218)
			     var reformed = reformer.ReformTermsSynchronously(new string);(line 221)
			     reformed = reformer.ReformTermsSynchronously(new string);(line 222)
			}

 
			public QueryPopolarWords(){(line 22)
			     Assert.IsTrue(thesaurus.GetSynonyms("red").Any());(line 25)
			     Assert.IsTrue(thesaurus.GetSynonyms("black").Any());(line 26)
			     Assert.IsTrue(thesaurus.GetSynonyms("peach").Any());(line 27)
			     Assert.IsTrue(thesaurus.GetSynonyms("house").Any());(line 28)
			     Assert.IsTrue(thesaurus.GetSynonyms("dictionary").Any());(line 29)
			     Assert.IsTrue(thesaurus.GetSynonyms("need").Any());(line 30)
			     Assert.IsTrue(thesaurus.GetSynonyms("sand").Any());(line 31)
			     Assert.IsTrue(thesaurus.GetSynonyms("monkey").Any());(line 32)
			}

 
			public QueryWiredWords(){(line 35)
			     Assert.IsFalse(thesaurus.GetSynonyms("obama").Any());(line 38)
			     Assert.IsFalse(thesaurus.GetSynonyms("georgewbush").Any());(line 39)
			     Assert.IsFalse(thesaurus.GetSynonyms("philly").Any());(line 40)
			     Assert.IsFalse(thesaurus.GetSynonyms("fdaf").Any());(line 41)
			     Assert.IsFalse(thesaurus.GetSynonyms("verylongwords").Any());(line 42)
			     Assert.IsFalse(thesaurus.GetSynonyms("???").Any());(line 43)
			     Assert.IsFalse(thesaurus.GetSynonyms("7455489735").Any());(line 44)
			     Assert.IsFalse(thesaurus.GetSynonyms(" ").Any());(line 45)
			}

 
			public GetSynonymsCorrectly(){(line 48)
			     Assert.IsTrue(thesaurus.GetSynonyms("see").Select().Contains("watch"));(line 51)
			     Assert.IsTrue(thesaurus.GetSynonyms("get").Select().Contains("have"));(line 52)
			     Assert.IsTrue(thesaurus.GetSynonyms("however").Select().Contains("nevertheless"));(line 53)
			     Assert.IsTrue(thesaurus.GetSynonyms("however").Select().Contains("withal"));(line 54)
			     Assert.IsTrue(thesaurus.GetSynonyms("however").Select().Contains("still"));(line 55)
			     Assert.IsTrue(thesaurus.GetSynonyms("however").Count() == 8);(line 56)
			}

 
			public TestPerformanceOfMatrix(){(line 23)
			     Stopwatch stopwatch = new Stopwatch();(line 26)
			     stopwatch.Start();(line 27)
			     matrix.Initialize(@"TestFiles\LargeMatrix");(line 28)
			     matrix.Dispose();(line 29)
			     stopwatch.Stop();(line 30)
			     Assert.IsTrue(stopwatch.ElapsedMilliseconds < 500);(line 31)
			}

 
			public GetStemmedWord(){(line 35)
			     for(int i = 0; i < 1000; i ++)(line 38)
			         string word = "adding";(line 40)
			         var stemmedWord = DictionaryHelper.GetStemmedQuery(word);(line 41)
			         Assert.IsTrue(stemmedWord.Equals("ad"));(line 42)
			         word = "add";(line 43)
			         stemmedWord = DictionaryHelper.GetStemmedQuery(word);(line 44)
			         Assert.IsTrue(stemmedWord.Equals("add"));(line 45)
			}

 
			public MakeSureCanNotAddShortWords(){(line 50)
			     for(int i = 0; i < 100; i ++)(line 53)
			         var word = GenerateRandomString(2);(line 55)
			         _dictionaryBasedSplitter.AddWords(new);(line 56)
			         Assert.IsTrue(! _dictionaryBasedSplitter.DoesWordExist(word,DictionaryOption.NoStemming));(line 57)
			}

 
			public AddSeveralWords(){(line 62)
			     string alpha = "abcdefghijklmnopqrstuvwxwz";(line 65)
			     int length = 3;(line 66)
			     var words = new List();(line 67)
			     for(int i = 0; i <= 26 - length; i ++)(line 69)
			         words.Add(alpha.Substring(i,length));(line 71)
			     this._dictionaryBasedSplitter.AddWords(words);(line 73)
			     foreach(string word)(line 74)
			         Assert.IsTrue(this._dictionaryBasedSplitter.DoesWordExist(word,DictionaryOption.NoStemming));(line 76)
			}

 
			public AddManyWords(){(line 81)
			     var words = new List();(line 84)
			     for(int i = 0; i < 100; i ++)(line 85)
			         words.Add(GenerateRandomString(30));(line 87)
			     this._dictionaryBasedSplitter.AddWords(words);(line 89)
			     foreach(string word)(line 90)
			         Assert.IsTrue(this._dictionaryBasedSplitter.DoesWordExist(word,DictionaryOption.NoStemming));(line 92)
			}

 
			public SplitPerformanceTest(){(line 97)
			     var words = GenerateRandomWordList(1000);(line 100)
			     this._dictionaryBasedSplitter.AddWords(words);(line 101)
			     for(int i = 0; i < 100; i ++)(line 102)
			         var combinedWords = CombiningWords(words,2);(line 104)
			         var watch = Stopwatch.StartNew();(line 105)
			         var subWords = this._dictionaryBasedSplitter.ExtractWords(combinedWords);(line 106)
			         var time = watch.ElapsedMilliseconds;(line 107)
			         Assert.IsTrue(time < 20);(line 108)
			         Assert.IsTrue(subWords.Count() == 2);(line 109)
			}

 
			public UpdateProjectNamesAndReloadOldOnes(){(line 113)
			     var projectNames = GenerateRandomWordList(10);(line 116)
			     var wordDictionary = new Dictionary();(line 117)
			     foreach(string project)(line 119)
			         CreateDirectory(tempFolder + project + @"\");(line 121)
			         _dictionaryBasedSplitter.Initialize(tempFolder + project + @"\");(line 122)
			         var words = GenerateRandomWordList(100);(line 123)
			         _dictionaryBasedSplitter.AddWords(words);(line 124)
			         wordDictionary.Add(project,words);(line 125)
			         _dictionaryBasedSplitter.Dispose();(line 126)
			     foreach(string project)(line 129)
			         _dictionaryBasedSplitter.Initialize(tempFolder + project + @"\");(line 131)
			         var words = wordDictionary[project];(line 132)
			         foreach(string word)(line 133)
			             Assert.IsTrue(_dictionaryBasedSplitter.DoesWordExist(word,DictionaryOption.NoStemming));(line 135)
			}

 
			public SplitSimpleWord(){(line 141)
			     _dictionaryBasedSplitter.AddWords(new string);(line 144)
			     var subWords = _dictionaryBasedSplitter.ExtractWords("inti");(line 145)
			     Assert.IsTrue(subWords[0].Equals("int"));(line 146)
			     Assert.IsTrue(subWords[1].Equals("i"));(line 147)
			}

 
			public SplitRandomWord(){(line 151)
			     for(int length = 0; length < 61; length ++)(line 154)
			         for(int i = 0; i < 100; i ++)(line 156)
			             var word = GenerateRandomString(length);(line 158)
			             _dictionaryBasedSplitter.ExtractWords(word);(line 159)
			}

 
			public SplitHalfSplittableWord(){(line 164)
			     int length = 30;(line 167)
			     var prefixes = GenerateRandomWordList(length);(line 168)
			     var middels = GenerateRandomWordList(length);(line 169)
			     var suffixes = GenerateRandomWordList(length);(line 170)
			     _dictionaryBasedSplitter.AddWords(prefixes);(line 171)
			     _dictionaryBasedSplitter.AddWords(suffixes);(line 172)
			     for(int i = 0; i < length; i ++)(line 173)
			         var sb = new StringBuilder();(line 175)
			         sb.Append(prefixes.ElementAt(i));(line 176)
			         sb.Append(middels.ElementAt(i));(line 177)
			         sb.Append(suffixes.ElementAt(i));(line 178)
			         var subWords = _dictionaryBasedSplitter.ExtractWords(sb.ToString());(line 179)
			         Assert.IsTrue(subWords.Count() >= 3);(line 180)
			         Assert.IsTrue(subWords.First().Equals(prefixes.ElementAt(i)));(line 181)
			         Assert.IsTrue(subWords.Last().Equals(suffixes.ElementAt(i)));(line 182)
			}

 
			public SplitSimpleQuote(){(line 186)
			     string quote = "\"inti\"";(line 189)
			     _dictionaryBasedSplitter.AddWords(new string);(line 190)
			     var words = _dictionaryBasedSplitter.ExtractWords(quote);(line 191)
			     Assert.IsTrue(words.Count() == 1);(line 192)
			     Assert.IsTrue(words.ElementAt(0).Equals(quote));(line 193)
			}

 
			public SplitQuoteWithNonQuote(){(line 196)
			     string quote = "\"inti\"";(line 199)
			     string nonQuote = "inti";(line 200)
			     string mix1 = quote + " " + nonQuote;(line 201)
			     string mix2 = nonQuote + " " + quote;(line 202)
			     string mix3 = nonQuote + " " + quote + " " + nonQuote;(line 203)
			     string mix4 = quote + " " + nonQuote + " " + quote;(line 204)
			     _dictionaryBasedSplitter.AddWords(new string);(line 205)
			     var words = _dictionaryBasedSplitter.ExtractWords(mix1);(line 207)
			     Assert.IsTrue(words.Count() == 3);(line 208)
			     Assert.IsTrue(words.ElementAt(0).Equals("\"inti\""));(line 209)
			     Assert.IsTrue(words.ElementAt(1).Equals("int"));(line 210)
			     Assert.IsTrue(words.ElementAt(2).Equals("i"));(line 211)
			     words = _dictionaryBasedSplitter.ExtractWords(mix2);(line 213)
			     Assert.IsTrue(words.Count() == 3);(line 214)
			     Assert.IsTrue(words.ElementAt(0).Equals("int"));(line 215)
			     Assert.IsTrue(words.ElementAt(1).Equals("i"));(line 216)
			     Assert.IsTrue(words.ElementAt(2).Equals("\"inti\""));(line 217)
			     words = _dictionaryBasedSplitter.ExtractWords(mix3);(line 219)
			     Assert.IsTrue(words.Count() == 5);(line 220)
			     Assert.IsTrue(words.ElementAt(0).Equals("int"));(line 221)
			     Assert.IsTrue(words.ElementAt(1).Equals("i"));(line 222)
			     Assert.IsTrue(words.ElementAt(2).Equals("\"inti\""));(line 223)
			     Assert.IsTrue(words.ElementAt(3).Equals("int"));(line 224)
			     Assert.IsTrue(words.ElementAt(4).Equals("i"));(line 225)
			     words = _dictionaryBasedSplitter.ExtractWords(mix4);(line 227)
			     Assert.IsTrue(words.Count() == 1);(line 228)
			}

 
			public SplitQuoteInsideQuote(){(line 232)
			     string keywords = "\"Assert.IsNotNull(wordSplitter, \"Default word splitter should x used!!\");\"";(line 235)
			     var words = _dictionaryBasedSplitter.ExtractWords(keywords);(line 236)
			     Assert.IsTrue(words.Count() == 1);(line 237)
			}

 
			public SplitEmptyQuote(){(line 240)
			     string quote = "\"\"";(line 243)
			     var words = _dictionaryBasedSplitter.ExtractWords(quote);(line 244)
			     Assert.IsTrue(words.Count() == 1);(line 245)
			     Assert.IsTrue(words.ElementAt(0).Equals(quote));(line 246)
			}

 
			public AddSpecialWords(){(line 249)
			     _dictionaryBasedSplitter.AddWords(new string);(line 252)
			     _dictionaryBasedSplitter.DoesWordExist("abb",DictionaryOption.NoStemming);(line 253)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsNullOrEmptyStringOrContainsWhiteSpaceOnly_THAN_ValidQueryDescriptionIsReturned(string query){(line 9)
			     var sandoQueryParser = new SandoQueryParser();(line 13)
			     var sandoQueryDescription = sandoQueryParser.Parse(null);(line 14)
			     Assert.IsFalse(sandoQueryDescription.IsValid);(line 16)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsLocationString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 19)
			     var sandoQueryParser = new SandoQueryParser();(line 23)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 24)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 26)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 27)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsLiteralString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 30)
			     var sandoQueryParser = new SandoQueryParser();(line 34)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 35)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 37)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 38)
			}

 
			public ParseFileH(){(line 41)
			     var sandoQueryParser = new SandoQueryParser();(line 44)
			     var sandoQueryDescription = sandoQueryParser.Parse("open file:h");(line 45)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 47)
			     Assert.IsTrue(sandoQueryDescription.SearchTerms.Count == 1);(line 48)
			}

 
			public ParseWithNegation(){(line 52)
			     var sandoQueryParser = new SandoQueryParser();(line 55)
			     var sandoQueryDescription = sandoQueryParser.Parse("reorder search results -test");(line 56)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 58)
			     Assert.IsTrue(sandoQueryDescription.SearchTerms.Count == 4);(line 59)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsFileExtensionString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 63)
			     var sandoQueryParser = new SandoQueryParser();(line 67)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 68)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 70)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 71)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsProgramElementTypeString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 74)
			     var sandoQueryParser = new SandoQueryParser();(line 78)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 79)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 81)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 82)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsAccessLevelString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 85)
			     var sandoQueryParser = new SandoQueryParser();(line 89)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 90)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 92)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 93)
			}

 
			public GIVEN_QueryParser_WHEN_ParseIsCalled_AND_QueryIsNormalString_THAN_ValidQueryDescriptionIsReturned(string query, string expectedQueryDescription){(line 96)
			     var sandoQueryParser = new SandoQueryParser();(line 100)
			     var sandoQueryDescription = sandoQueryParser.Parse(query);(line 101)
			     Assert.IsTrue(sandoQueryDescription.IsValid);(line 103)
			     Assert.AreEqual(expectedQueryDescription,sandoQueryDescription.ToString());(line 104)
			}

 
			public Analyzer(){(line 13)
			     var manager = new SandoAnalysisManager(@"C:\downloads\sando");(line 16)
			}

 
			public TestMultiQueries(){(line 31)
			     for(int i = 0; i < 900; i ++)(line 34)
			         var query = GenerateRandomString(20);(line 36)
			         history.IssuedSearchString(query);(line 37)
			         Assert.IsTrue(history.GetSearchHistoryItems().Any());(line 38)
			}

 
			public EnsureQueriesSavedCorrectly(){(line 74)
			     Assert.IsTrue(queries.All());(line 77)
			}

 
			public EnsureTimeSavedCorrectly(){(line 81)
			     var now = DateTime.Now.Ticks;(line 84)
			     foreach(var query)(line 85)
			         string q = query;(line 87)
			         var entry = history.GetSearchHistoryItems().First();(line 88)
			         Assert.IsTrue(entry.TimeStamp < now);(line 89)
			         Assert.IsTrue(now - entry.TimeStamp < 1 * 1000 * 10000);(line 92)
			}

 
			public QueryFreqentWord(){(line 21)
			     AssertWordExist("add");(line 24)
			     AssertWordExist("get");(line 25)
			     AssertWordExist("debug");(line 26)
			     AssertWordExist("retrieve");(line 27)
			     AssertWordExist("file");(line 28)
			     AssertWordExist("release");(line 29)
			}

 
			public QueryNonExistingWord(){(line 32)
			     AssertNonExistingWord("fafad");(line 35)
			     AssertNonExistingWord("");(line 36)
			     AssertNonExistingWord(null);(line 37)
			     AssertNonExistingWord("&*##@");(line 38)
			     AssertNonExistingWord("324312");(line 39)
			}

 
			public AddMultipleWords(){(line 15)
			     var matrix = new SparseCoOccurrenceMatrix();(line 18)
			     var words = this.GenerateRandomWordList(30);(line 19)
			     matrix.HandleCoOcurrentWordsSync(words);(line 20)
			     for(int i = 0; i < words.Count - 1; i ++)(line 21)
			         var word1 = words.ElementAt(i);(line 23)
			         var word2 = words.ElementAt(i + 1);(line 24)
			         Assert.IsTrue(matrix.GetCoOccurrenceCount(word1,word2) > 0);(line 25)
			     for(int i = 0; i < words.Count - 5; i ++)(line 28)
			         var word1 = words.ElementAt(i);(line 30)
			         var word2 = words.ElementAt(i + 4);(line 31)
			         Assert.IsTrue(matrix.GetCoOccurrenceCount(word1,word2) == 0);(line 32)
			}

 
			public AddMultipleWordsMultipleTimes(){(line 38)
			     var matrix = new SparseCoOccurrenceMatrix();(line 41)
			     var words = this.GenerateRandomWordList(30);(line 42)
			     matrix.HandleCoOcurrentWordsSync(words);(line 43)
			     var words2 = this.GenerateRandomWordList(30);(line 44)
			     matrix.HandleCoOcurrentWordsSync(words2);(line 45)
			     for(int i = 0; i < words.Count - 1; i ++)(line 47)
			         var word1 = words.ElementAt(i);(line 49)
			         var word2 = words.ElementAt(i + 1);(line 50)
			         Assert.IsTrue(matrix.GetCoOccurrenceCount(word1,word2) > 0);(line 51)
			     for(int i = 0; i < words2.Count - 1; i ++)(line 54)
			         var word1 = words2.ElementAt(i);(line 56)
			         var word2 = words2.ElementAt(i + 1);(line 57)
			         Assert.IsTrue(matrix.GetCoOccurrenceCount(word1,word2) > 0);(line 58)
			     for(int i = 0; i < words.Count; i ++)(line 61)
			         var word1 = words.ElementAt(i);(line 63)
			         var word2 = words2.ElementAt(i);(line 64)
			         Assert.IsTrue(matrix.GetCoOccurrenceCount(word1,word2) == 0);(line 65)
			}

 
			public GetAllEntriesFast(){(line 69)
			     var matrix = new SparseCoOccurrenceMatrix();(line 72)
			     var words = GenerateRandomWordList(30);(line 73)
			     matrix.HandleCoOcurrentWordsSync(words);(line 74)
			     var entries = matrix.GetEntries();(line 75)
			}

 
			public TestSplitCamelCase(){(line 16)
			     string parts = wordSplitter.ExtractWords("aLongVariableNameInCamelCase");(line 19)
			     Assert.AreEqual(parts.Length,7);(line 20)
			}

 
			public ExtractSearchTermsTestLeaveCompleteTerm(){(line 23)
			     var parts = WordSplitter.ExtractSearchTerms("_solutionEvents");(line 26)
			     Assert.AreEqual(parts.Count,1);(line 27)
			     Assert.IsTrue(parts.Contains("\"_solutionEvents\""));(line 28)
			}

 
			public TestSplitUnderscores(){(line 33)
			     string parts = wordSplitter.ExtractWords("a_name_separated_by_lots_of_underscores");(line 36)
			     Assert.AreEqual(parts.Length,7);(line 37)
			}

 
			public TestUnsplittable(){(line 40)
			     string parts = wordSplitter.ExtractWords("unsplittable");(line 43)
			     Assert.AreEqual(parts.Length,1);(line 44)
			}

 
			public TestAbbreviations(){(line 47)
			     string parts = wordSplitter.ExtractWords("whatAboutALM");(line 50)
			     Assert.IsTrue(parts.Length == 3);(line 51)
			}

 
			public TestAllCaps(){(line 54)
			     string parts = wordSplitter.ExtractWords("WHATIFALLINCAPS");(line 57)
			     Assert.AreEqual(parts.Length,1);(line 58)
			}

 
			public TestAllCapsUnderscore(){(line 61)
			     string parts = wordSplitter.ExtractWords("WHAT_IF_ALL_IN_CAPS");(line 64)
			     Assert.AreEqual(parts.Length,5);(line 65)
			}

 
			public TestBeginUnderscore(){(line 68)
			     string parts = wordSplitter.ExtractWords("_beginInUnderscore");(line 71)
			     Assert.AreEqual(parts.Length,3);(line 72)
			}

 
			public ShortcutInName(){(line 75)
			     string parts = wordSplitter.ExtractWords("FBIInUnderscore");(line 78)
			     Assert.AreEqual(parts.Length,3);(line 79)
			}

 
			public PseudoShortcutInName(){(line 82)
			     string parts = wordSplitter.ExtractWords("IInUnderscore");(line 85)
			     Assert.AreEqual(parts.Length,3);(line 86)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenQuotesUsed(){(line 89)
			     List<string> parts = WordSplitter.ExtractSearchTerms("word \"words inside quotes\" another_word");(line 92)
			     Assert.AreEqual(1,parts.Count);(line 93)
			     Assert.AreEqual("\"word \"words inside quotes\" another_word\"",String.Join("*",parts));(line 94)
			     parts = WordSplitter.ExtractSearchTerms("return \"..\\\\..\\\\Parser\"");(line 96)
			     Assert.AreEqual(1,parts.Count);(line 97)
			     Assert.AreEqual("\"return \"..\\\\..\\\\Parser\"\"",String.Join("*",parts));(line 98)
			}

 
			public InterpretSearchQuery(){(line 101)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("Assert.AreEqual(4, parts.Count);"));(line 104)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("public void ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenQuotesUsedInsideQuotes()"));(line 105)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenQuotesUsedInsideQuotes("));(line 106)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("WordSplitter.InvalidCharactersFound(\"\"wordSplitter.ExtractWords(\"IInUnderscore\")\"\")"));(line 107)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("simpleSearchCriteria.ToQueryString();"));(line 108)
			     Assert.IsFalse(WordSplitter.IsUnquotedLiteral("open file"));(line 109)
			     Assert.IsFalse(WordSplitter.IsUnquotedLiteral("\"sadfasdfasdfasdfasdfasdf\""));(line 110)
			     Assert.IsFalse(WordSplitter.IsUnquotedLiteral(" \"sadfasdfasdfasdfasdfasdf\" "));(line 111)
			     Assert.IsFalse(WordSplitter.IsUnquotedLiteral(" open file -test "));(line 112)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("\"sadfasdfasdfasdfasdfasdf\" test"));(line 113)
			     Assert.IsTrue(WordSplitter.IsUnquotedLiteral("return \"..\\..\\Parser\";"));(line 114)
			     var parsed = WordSplitter.ExtractSearchTerms("return \"..\\..\\Parser\";").ToArray();(line 116)
			     Assert.IsTrue(parsed.Equals("\"return \"..\\..\\Parser\";\""));(line 117)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenQuotesUsedInsideQuotes(){(line 120)
			     Assert.IsFalse(WordSplitter.InvalidCharactersFound("\"wordSplitter.ExtractWords(\"IInUnderscore\")\""));(line 123)
			     Assert.IsFalse(WordSplitter.InvalidCharactersFound("\"Assert.IsNotNull(wordSplitter, \"Default word splitter should be used!\");\""));(line 124)
			     Assert.IsNotNull(WordSplitter.ExtractSearchTerms("\"Assert.IsNotNull(wordSplitter, \"Default word splitter should be used!\");\""));(line 125)
			     List<string> parts = WordSplitter.ExtractSearchTerms("\"wordSplitter.ExtractWords(\"IInUnderscore\")\"");(line 126)
			     Assert.AreEqual(1,parts.Count);(line 127)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenQuotesUsedWithInvalidQuote(){(line 130)
			     List<string> parts = WordSplitter.ExtractSearchTerms("word \"words inside quotes\" another word");(line 133)
			     Assert.AreEqual(1,parts.Count);(line 134)
			     Assert.AreEqual(String.Join("*",parts),"\"word \"words inside quotes\" another word\"");(line 135)
			}

 
			public ExtractSearchTerms_SlashesInsideQuotesInsideQuote(){(line 139)
			     List<string> parts = WordSplitter.ExtractSearchTerms("IsUnquotedLiteral(\"..\\Path\"))");(line 143)
			     Assert.AreEqual(1,parts.Count);(line 144)
			     Assert.AreEqual("\"IsUnquotedLiteral(\"..\\Path\"))\"",String.Join(" ",parts));(line 145)
			     parts = WordSplitter.ExtractSearchTerms("\"IsUnquotedLiteral(\"..\\Path\"))\"");(line 148)
			     Assert.AreEqual(1,parts.Count);(line 149)
			     Assert.AreEqual("\"IsUnquotedLiteral(\"..\\Path\"))\"",String.Join(" ",parts));(line 150)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenColonUsed(){(line 153)
			     List<string> parts = WordSplitter.ExtractSearchTerms("file::open::now");(line 156)
			     Assert.AreEqual(1,parts.Count);(line 157)
			     Assert.AreEqual("\"file::open::now\"",String.Join(" ",parts));(line 158)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenEqualityOperatorUsed(){(line 161)
			     List<string> parts = WordSplitter.ExtractSearchTerms("file=new");(line 164)
			     Assert.AreEqual(1,parts.Count);(line 165)
			     Assert.AreEqual("\"file=new\"",String.Join(" ",parts));(line 166)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenBracketsUsed(){(line 169)
			     List<string> parts = WordSplitter.ExtractSearchTerms("file(new File())");(line 172)
			     Assert.AreEqual(1,parts.Count);(line 173)
			     Assert.AreEqual("\"file(new File())\"",String.Join(" ",parts));(line 174)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenUpperCasesUsed1(){(line 177)
			     List<string> parts = WordSplitter.ExtractSearchTerms("fileOpenNow");(line 180)
			     Assert.AreEqual(4,parts.Count);(line 181)
			     Assert.AreEqual("fileopennow file open now",String.Join(" ",parts));(line 182)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenUpperCasesUsed2(){(line 185)
			     List<string> parts = WordSplitter.ExtractSearchTerms("FileOpenNow");(line 188)
			     Assert.AreEqual(4,parts.Count);(line 189)
			     Assert.AreEqual("fileopennow file open now",String.Join(" ",parts));(line 190)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenUpperCasesUsed3(){(line 193)
			     List<string> parts = WordSplitter.ExtractSearchTerms("FileTXTOpenNow");(line 196)
			     Assert.AreEqual(5,parts.Count);(line 197)
			     Assert.AreEqual("filetxtopennow file txt open now",String.Join(" ",parts));(line 198)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenNumbersUsed(){(line 201)
			     List<string> parts = WordSplitter.ExtractSearchTerms("file324");(line 204)
			     Assert.AreEqual(3,parts.Count);(line 205)
			     Assert.AreEqual("file324 file 324",String.Join(" ",parts));(line 206)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenNumbersUsed2(){(line 209)
			     List<string> parts = WordSplitter.ExtractSearchTerms("Mp3Player");(line 212)
			     Assert.AreEqual(4,parts.Count);(line 213)
			     Assert.AreEqual("mp3player mp 3 player",String.Join(" ",parts));(line 214)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenUnderscoreUsed(){(line 217)
			     List<string> parts = WordSplitter.ExtractSearchTerms("file_open_now");(line 220)
			     Assert.AreEqual(1,parts.Count);(line 221)
			     Assert.AreEqual("\"file_open_now\"",String.Join(" ",parts));(line 222)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenNoQuotesUsed(){(line 225)
			     List<string> parts = WordSplitter.ExtractSearchTerms("word words inside quotes another_word");(line 228)
			     Assert.AreEqual(1,parts.Count);(line 229)
			     Assert.AreEqual(String.Join("*",parts),"\"word words inside quotes another_word\"");(line 230)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenNoOperatortUsedWithQuotes(){(line 233)
			     List<string> parts = WordSplitter.ExtractSearchTerms("word \"words inside\"");(line 236)
			     Assert.AreEqual(1,parts.Count);(line 237)
			     Assert.AreEqual("\"word \"words inside\"\"",String.Join("*",parts));(line 238)
			}

 
			public ExtractSearchTerms_ReturnsValidNumberOfSearchTermsWhenNoOperatortUsedWithoutQuotes(){(line 241)
			     List<string> parts = WordSplitter.ExtractSearchTerms("word -about");(line 244)
			     Assert.AreEqual(2,parts.Count);(line 245)
			     Assert.AreEqual("word*-about",String.Join("*",parts));(line 246)
			}

 
			public ExtractSearchTerms_ReturnsEmptyListWhenSearchTermIsEmptyString(){(line 249)
			     List<string> parts = WordSplitter.ExtractSearchTerms(String.Empty);(line 252)
			     Assert.AreEqual(0,parts.Count);(line 253)
			}

 
			public InvalidCharactersFound_ReturnsTrueWhenInvalidCharactersUsed(){(line 258)
			     bool invalidCharactersFound = WordSplitter.InvalidCharactersFound("???");(line 261)
			     Assert.IsTrue(invalidCharactersFound);(line 262)
			}

 
			public ParsingQuery(){(line 265)
			     bool invalidCharactersFound = WordSplitter.InvalidCharactersFound("session file info filetype:h");(line 268)
			     Assert.IsFalse(invalidCharactersFound);(line 269)
			     var terms = WordSplitter.ExtractSearchTerms("session file info filetype:h");(line 270)
			     WordSplitter.GetFileExtensions("session file info filetype:h");(line 271)
			}

 
			public InvalidCharactersFound_ReturnsFalseWhenInvalidCharactersUsedInQuotes(){(line 274)
			     bool invalidCharactersFound = WordSplitter.InvalidCharactersFound("\"???\"");(line 277)
			     Assert.IsFalse(invalidCharactersFound);(line 278)
			}

 
			public ExtractSearchTerms_ContractFailsWhenSearchTermIsNull(){(line 281)
			     try(line 284)
			         WordSplitter.ExtractSearchTerms(null);(line 286)
			     catch()(line 288)
			     Assert.True(contractFailed,"Contract should fail!");(line 292)
			}

 
			public ExtractSearchTerms_FirstPartIsAlwaysOriginal(){(line 295)
			     string term1 = "splitWord";(line 298)
			     string term2 = "splitAgain";(line 299)
			     List<string> parts = WordSplitter.ExtractSearchTerms(term1);(line 300)
			     Assert.AreEqual(3,parts.Count);(line 301)
			     Assert.AreEqual(parts[0],term1.ToLower());(line 302)
			     parts = WordSplitter.ExtractSearchTerms(term2);(line 304)
			     Assert.AreEqual(3,parts.Count);(line 305)
			     Assert.AreEqual(parts[0],term2.ToLower());(line 306)
			     parts = WordSplitter.ExtractSearchTerms(term1 + " " + term2);(line 308)
			     Assert.AreEqual(5,parts.Count);(line 309)
			     Assert.AreEqual(parts[0],term1.ToLower());(line 310)
			     Assert.AreEqual(parts[1],term2.ToLower());(line 311)
			}

 
			public TestPerformance(){(line 314)
			     var watch = new Stopwatch();(line 317)
			     watch.Start();(line 318)
			     for(int i = 0; i < 500; i ++)(line 319)
			         string parts = wordSplitter.ExtractWords("_beginInUnderscore");(line 321)
			         Assert.IsTrue(parts.Length == 3);(line 322)
			     watch.Stop();(line 324)
			     Assert.IsTrue(watch.ElapsedMilliseconds < 500);(line 325)
			}

 
			public AddOneTask(){(line 50)
			     processor.AddTimedTask(incrementField,10);(line 53)
			     Thread.Sleep(1000);(line 54)
			     EnsureFieldCondition();(line 55)
			     EnsureFieldCondition();(line 56)
			     processor.RemoveTimedTask(incrementField);(line 57)
			}

 
			public AddTwoTasks(){(line 60)
			     processor.AddTimedTask(incrementField,5);(line 63)
			     processor.AddTimedTask(decrementField,10);(line 64)
			     Thread.Sleep(1000);(line 65)
			     EnsureFieldCondition();(line 66)
			     EnsureFieldCondition();(line 67)
			     processor.RemoveTimedTask(incrementField);(line 68)
			     processor.RemoveTimedTask(decrementField);(line 69)
			}

 
			public TestDistinctBy(){(line 26)
			     var d1 = new Data("a",2,2.3f);(line 29)
			     var d2 = new Data("a",3,3.4f);(line 30)
			     var d3 = new Data("a",4,1.1f);(line 31)
			     var list = new;(line 32)
			     list = list.DistinctBy().ToArray();(line 33)
			     Assert.IsTrue(list.Count() == 1);(line 34)
			     d1 = new Data("a",1,3.2f);(line 36)
			     d2 = new Data("b",1,2.2f);(line 37)
			     d3 = new Data("c",1,12.2f);(line 38)
			     list = new;(line 39)
			     list = list.DistinctBy().ToArray();(line 40)
			     Assert.IsTrue(list.Length == 1);(line 41)
			     d1 = new Data("a",1,3.2f);(line 43)
			     d2 = new Data("b",2,2.2f);(line 44)
			     d3 = new Data("c",1,12.2f);(line 45)
			     list = new;(line 46)
			     list = list.DistinctBy().ToArray();(line 47)
			     Assert.IsTrue(list.Length == 2);(line 48)
			}

 
			public AddMultipleWords(){(line 49)
			     corrector.AddWords(GenerateRandomWordList(200));(line 52)
			}

 
			public RandomIntegersTest(){(line 55)
			     var min = 0;(line 58)
			     var max = 100;(line 59)
			     var lowReached = false;(line 60)
			     var highReached = false;(line 61)
			     for(int i = 0; i < 1000; i ++)(line 62)
			         var value = GenerateRandomInt(min,max);(line 64)
			         Assert.IsTrue(value >= min);(line 65)
			         Assert.IsTrue(value <= max);(line 66)
			         if(value == min)(line 67)
			             lowReached = true;(line 68)
			         if(value == max)(line 69)
			             highReached = true;(line 70)
			     Assert.IsTrue(lowReached);(line 72)
			     Assert.IsTrue(highReached);(line 73)
			}

 
			public QuerySameWords(){(line 77)
			     for(int i = 0; i < 100; i ++)(line 80)
			         string word = GenerateRandomString(20);(line 82)
			         corrector.AddWords(GenerateRandomWordList(200));(line 83)
			         corrector.AddWords(new string);(line 84)
			         var results = corrector.FindSimilarWords(word).ToArray();(line 85)
			         Assert.IsNotNull(results);(line 86)
			         Assert.IsTrue(results.Any());(line 87)
			         Assert.IsTrue(results.First().Equals(word));(line 88)
			}

 
			public QuerySlightlyDifferentWords(){(line 92)
			     for(int i = 0; i < 100; i ++)(line 95)
			         string word = GenerateRandomString(20);(line 97)
			         corrector.AddWords(GenerateRandomWordList(200));(line 98)
			         corrector.AddWords(new string);(line 99)
			         int splitIndex = GenerateRandomInt(0,word.Length - 1);(line 100)
			         var changedWord = word.Substring(0,splitIndex + 1) + GenerateRandomChar() + word.Substring(splitIndex + 1);(line 101)
			         var results = corrector.FindSimilarWords(changedWord).ToArray();(line 103)
			         Assert.IsNotNull(results);(line 104)
			         Assert.IsTrue(results.Any());(line 105)
			         Assert.IsTrue(results.First().Equals(word));(line 106)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomParser(){(line 25)
			     CreateExtensionPointsConfiguration(addValidParserConfigurations : true);(line 28)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 29)
			     IParser parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cs");(line 31)
			     Assert.IsNotNull(parser,"Parser for '.cs' extension should be registered!");(line 33)
			     List<ProgramElement> programElements = null;(line 34)
			     Assert.DoesNotThrow();(line 35)
			     Assert.IsTrue(programElements != null && programElements.Count == 1,"Invalid results from Parse method!");(line 36)
			     Assert.AreEqual(programElements[0].Name,"TestCSharpName","Name differs!");(line 37)
			     Assert.AreEqual(programElements[0].GetType().FullName,"Sando.TestExtensionPoints.TestElement","Type differs!");(line 38)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomWordSplitter(){(line 41)
			     CreateExtensionPointsConfiguration(addValidWordSplitterConfiguration : true);(line 44)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 45)
			     IWordSplitter wordSplitter = ExtensionPointsRepository.Instance.GetWordSplitterImplementation();(line 47)
			     Assert.IsNotNull(wordSplitter,"Word splitter should be registered!");(line 48)
			     Assert.AreEqual(wordSplitter.GetType().FullName,"Sando.TestExtensionPoints.TestWordSplitter","Invalid word splitter returned!");(line 49)
			     string splittedWords = null;(line 51)
			     Assert.DoesNotThrow();(line 52)
			     Assert.IsTrue(splittedWords != null && splittedWords.Length == 2,"Invalid results from ExtractWords method!");(line 53)
			     Assert.AreEqual(splittedWords[0],"File","First splitted word is invalid!");(line 54)
			     Assert.AreEqual(splittedWords[1],"Name","Second splitted word is invalid!");(line 55)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomResultsReorderer(){(line 58)
			     CreateExtensionPointsConfiguration(addValidResultsReordererConfiguration : true);(line 61)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 62)
			     IResultsReorderer resultsReorderer = ExtensionPointsRepository.Instance.GetResultsReordererImplementation();(line 64)
			     Assert.IsNotNull(resultsReorderer,"Results reorderer should be registered!");(line 65)
			     Assert.AreEqual(resultsReorderer.GetType().FullName,"Sando.TestExtensionPoints.TestResultsReorderer","Invalid results reorderer returned!");(line 66)
			     List<CodeSearchResult> results = new List();(line 68)
			     Assert.DoesNotThrow();(line 73)
			     Assert.IsTrue(results != null && results.Count() == 2,"Invalid results from ReorderSearchResults method!");(line 74)
			     Assert.IsTrue(results.ElementAt(0).Score == 3 && results.ElementAt(0).ProgramElement.ProgramElementType == ProgramElementType.Method,"First result is invalid!");(line 75)
			     Assert.IsTrue(results.ElementAt(1).Score == 1 && results.ElementAt(1).ProgramElement.ProgramElementType == ProgramElementType.Class,"Second result is invalid!");(line 76)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomQueryWeightsSupplier(){(line 79)
			     CreateExtensionPointsConfiguration(addValidQueryWeightsSupplierConfiguration : true);(line 82)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 83)
			     IQueryWeightsSupplier queryWeightsSupplier = ExtensionPointsRepository.Instance.GetQueryWeightsSupplierImplementation();(line 85)
			     Assert.IsNotNull(queryWeightsSupplier,"Query weights supplier should be registered!");(line 86)
			     Assert.AreEqual(queryWeightsSupplier.GetType().FullName,"Sando.TestExtensionPoints.TestQueryWeightsSupplier","Invalid query weights supplier returned!");(line 87)
			     Dictionary<string,float> weights = null;(line 89)
			     Assert.DoesNotThrow();(line 90)
			     Assert.IsTrue(weights != null && weights.Count() == 2,"Invalid results from SetQueryWeightsValues method!");(line 91)
			     Assert.AreEqual(weights["field1"],2,"First weight is invalid!");(line 92)
			     Assert.AreEqual(weights["field2"],3,"Second weight is invalid!");(line 93)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomQueryRewriter(){(line 96)
			     CreateExtensionPointsConfiguration(addValidQueryRewriterConfiguration : true);(line 99)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 100)
			     IQueryRewriter queryRewriter = ExtensionPointsRepository.Instance.GetQueryRewriterImplementation();(line 102)
			     Assert.IsNotNull(queryRewriter,"Query rewriter should be registered!");(line 103)
			     Assert.AreEqual(queryRewriter.GetType().FullName,"Sando.TestExtensionPoints.TestQueryRewriter","Invalid query rewriter returned!");(line 104)
			     string query = null;(line 106)
			     Assert.DoesNotThrow();(line 107)
			     Assert.IsFalse(String.IsNullOrWhiteSpace(query),"Invalid results from RewriteQuery method!");(line 108)
			     Assert.AreEqual(query,"two keywords","Query is invalid!");(line 109)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersUsableCustomIndexFilterManager(){(line 112)
			     CreateExtensionPointsConfiguration(addValidIndexFilterManagerConfiguration : true);(line 115)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 116)
			     IIndexFilterManager indexFilterManager = ExtensionPointsRepository.Instance.GetIndexFilterManagerImplementation();(line 118)
			     Assert.IsNotNull(indexFilterManager,"Index filter manager should be registered!");(line 119)
			     Assert.AreEqual(indexFilterManager.GetType().FullName,"Sando.TestExtensionPoints.TestIndexFilterManager","Invalid index filter manager returned!");(line 120)
			     bool shouldBeIndexed = false;(line 122)
			     Assert.DoesNotThrow();(line 123)
			     Assert.IsTrue(shouldBeIndexed,"Invalid results from ShouldFileBeIndexed method!");(line 124)
			}

 
			public FindAndRegisterValidExtensionPoints_RegistersCustomParsers(){(line 127)
			     CreateExtensionPointsConfiguration(addValidParserConfigurations : true);(line 130)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 131)
			     IParser parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cs");(line 133)
			     Assert.IsNotNull(parser,"Parser for '.cs' extension should be registered!");(line 134)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.TestExtensionPoints.TestCSharpParser","Invalid parser returned for '.cs' extension!");(line 135)
			     parser = ExtensionPointsRepository.Instance.GetParserImplementation(".h");(line 137)
			     Assert.IsNotNull(parser,"Parser for '.h' extension should be registered!");(line 138)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.TestExtensionPoints.TestCppParser","Invalid parser returned for '.h' extension!");(line 139)
			     parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cpp");(line 141)
			     Assert.IsNotNull(parser,"Parser for '.cpp' extension should be registered!");(line 142)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.TestExtensionPoints.TestCppParser","Invalid parser returned for '.cpp' extension!");(line 143)
			     parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cxx");(line 145)
			     Assert.IsNotNull(parser,"Parser for '.cxx' extension should be registered!");(line 146)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.TestExtensionPoints.TestCppParser","Invalid parser returned for '.cxx' extension!");(line 147)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomParserConfigurations(){(line 150)
			     CreateExtensionPointsConfiguration(addInvalidParserConfigurations : true);(line 153)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 154)
			     IParser parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cs");(line 156)
			     Assert.IsNotNull(parser,"Default parser for '.cs' extension should be used!");(line 157)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.Parser.SrcMLCSharpParser","Invalid parser returned for '.cs' extension!");(line 158)
			     string logFileContent = File.ReadAllText(logFilePath);(line 160)
			     Assert.IsTrue(logFileContent.Contains("3 invalid parser configurations found - they will be omitted during registration process."),"Log file should contain information about removed invalid parser configurations!");(line 161)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomWordSplitterConfiguration(){(line 164)
			     CreateExtensionPointsConfiguration(addInvalidWordSplitterConfiguration : true);(line 167)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 168)
			     IWordSplitter wordSplitter = ExtensionPointsRepository.Instance.GetWordSplitterImplementation();(line 170)
			     Assert.IsNotNull(wordSplitter,"Default word splitter should x used!!");(line 171)
			     Assert.AreEqual(wordSplitter.GetType().FullName,"Sando.Core.Tools.WordSplitter","Invalid word splitter returned!");(line 172)
			     string logFileContent = File.ReadAllText(logFilePath);(line 174)
			     Assert.IsTrue(logFileContent.Contains("Invalid word splitter configuration found - it will be omitted during registration process."),"Log file should contain information about removed invalid word splitter configuration!");(line 175)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomResultsReordererConfiguration(){(line 178)
			     CreateExtensionPointsConfiguration(addInvalidResultsReordererConfiguration : true);(line 181)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 182)
			     IResultsReorderer resultsReorderer = ExtensionPointsRepository.Instance.GetResultsReordererImplementation();(line 184)
			     Assert.IsNotNull(resultsReorderer,"Default results reorderer should be used!");(line 185)
			     Assert.AreEqual(resultsReorderer.GetType().FullName,"Sando.SearchEngine.SortByScoreResultsReorderer","Invalid results reorderer returned!");(line 186)
			     string logFileContent = File.ReadAllText(logFilePath);(line 188)
			     Assert.IsTrue(logFileContent.Contains("Invalid results reorderer configuration found - it will be omitted during registration process."),"Log file should contain information about removed invalid word splitter configuration!");(line 189)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomQueryWeightsSupplierConfiguration(){(line 192)
			     CreateExtensionPointsConfiguration(addInvalidQueryWeightsSupplierConfiguration : true);(line 195)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 196)
			     IQueryWeightsSupplier queryWeightsSupplier = ExtensionPointsRepository.Instance.GetQueryWeightsSupplierImplementation();(line 198)
			     Assert.IsNotNull(queryWeightsSupplier,"Default query weights supplier should be used!");(line 199)
			     Assert.AreEqual(queryWeightsSupplier.GetType().FullName,"Sando.Indexer.Searching.QueryWeightsSupplier","Invalid query weights supplier returned!");(line 200)
			     string logFileContent = File.ReadAllText(logFilePath);(line 202)
			     Assert.IsTrue(logFileContent.Contains("Invalid query weights supplier configuration found - it will be omitted during registration process."),"Log file should contain information about removed invalid word splitter configuration!");(line 203)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomQueryRewriterConfiguration(){(line 206)
			     CreateExtensionPointsConfiguration(addInvalidQueryRewriterConfiguration : true);(line 209)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 210)
			     IQueryRewriter queryRewriter = ExtensionPointsRepository.Instance.GetQueryRewriterImplementation();(line 212)
			     Assert.IsNotNull(queryRewriter,"Default query rewriter should be used!");(line 213)
			     Assert.AreEqual(queryRewriter.GetType().FullName,"Sando.Indexer.Searching.DefaultQueryRewriter","Invalid query rewriter returned!");(line 214)
			     string logFileContent = File.ReadAllText(logFilePath);(line 216)
			     Assert.IsTrue(logFileContent.Contains("Invalid query rewriter configuration found - it will be omitted during registration process."),"Log file should contain information about removed invalid query rewriter configuration!");(line 217)
			}

 
			public FindAndRegisterValidExtensionPoints_RemovesInvalidCustomIndexFilterManagerConfiguration(){(line 220)
			     CreateExtensionPointsConfiguration(addInvalidIndexFilterManagerConfiguration : true);(line 223)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 224)
			     IIndexFilterManager indexFilterManager = ExtensionPointsRepository.Instance.GetIndexFilterManagerImplementation();(line 226)
			     Assert.IsNotNull(indexFilterManager,"Default index filter manager should be used!");(line 227)
			     Assert.AreEqual(indexFilterManager.GetType().FullName,"Sando.Indexer.IndexFiltering.IndexFilterManager","Invalid index filter manager returned!");(line 228)
			     string logFileContent = File.ReadAllText(logFilePath);(line 230)
			     Assert.IsTrue(logFileContent.Contains("Invalid index filter manager configuration found - it will be omitted during registration process."),"Log file should contain information about removed invalid index filter manager configuration!");(line 231)
			}

 
			public FindAndRegisterValidExtensionPoints_DoesNotRegisterInvalidExtensionPoints(){(line 234)
			     CreateExtensionPointsConfiguration(addInvalidExtensionPoints : true);(line 237)
			     ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(extensionPointsConfiguration,logger);(line 238)
			     IParser parser = ExtensionPointsRepository.Instance.GetParserImplementation(".cs");(line 240)
			     Assert.IsNotNull(parser,"Default parser for '.cs' extension should be used!");(line 241)
			     Assert.AreEqual(parser.GetType().FullName,"Sando.Parser.SrcMLCSharpParser","Invalid parser returned for '.cs' extension!");(line 242)
			     IWordSplitter wordSplitter = ExtensionPointsRepository.Instance.GetWordSplitterImplementation();(line 244)
			     Assert.IsNotNull(wordSplitter,"Default word splitter should be used!");(line 245)
			     Assert.AreEqual(wordSplitter.GetType().FullName,"Sando.Core.Tools.WordSplitter","Invalid word splitter returned!");(line 246)
			     IResultsReorderer resultsReorderer = ExtensionPointsRepository.Instance.GetResultsReordererImplementation();(line 248)
			     Assert.IsNotNull(resultsReorderer,"Default results reorderer should be used!");(line 249)
			     Assert.AreEqual(resultsReorderer.GetType().FullName,"Sando.SearchEngine.SortByScoreResultsReorderer","Invalid results reorderer returned!");(line 250)
			     string logFileContent = File.ReadAllText(logFilePath);(line 252)
			     Assert.IsTrue(logFileContent.Contains("Type cannot be found: Sando.NonExistingParser"),"Log file should contain information about errors occurred during the assembly loading!");(line 253)
			     Assert.IsTrue(logFileContent.Contains("Could not load file or assembly 'file:///" + pluginDirectory + "NonExistingParser.dll' or one of its dependencies"),"Log file should contain information about errors occurred during the assembly loading!");(line 254)
			     Assert.IsTrue(logFileContent.Contains("Could not load file or assembly 'file:///" + pluginDirectory + "NonExistingTestElement.dll' or one of its dependencies"),"Log file should contain information about errors occurred during the assembly loading!");(line 255)
			     Assert.IsTrue(logFileContent.Contains("Could not load file or assembly 'file:///" + pluginDirectory + "NonExistingWordSplitter.dll' or one of its dependencies"),"Log file should contain information about errors occurred during the assembly loading!");(line 256)
			     Assert.IsTrue(logFileContent.Contains("Type cannot be found: Sando.TestExtensionPoints.NonExistingResultsReorderer"),"Log file should contain information about errors occurred during the assembly loading!");(line 257)
			     Assert.IsTrue(logFileContent.Contains("Type cannot be found: Sando.TestExtensionPoints.NonExistingQueryWeightsSupplier"),"Log file should contain information about errors occurred during the assembly loading!");(line 258)
			     Assert.IsTrue(logFileContent.Contains("Type cannot be found: Sando.TestExtensionPoints.NonExistingQueryRewriter"),"Log file should contain information about errors occurred during the assembly loading!");(line 259)
			     Assert.IsTrue(logFileContent.Contains("Type cannot be found: Sando.TestExtensionPoints.NonExistingIndexFilterManager"),"Log file should contain information about errors occurred during the assembly loading!");(line 260)
			}

 
			public GetParserImplementation_ReturnsParserWhenCalledWithLowerOrUpperCasedExtensionName(){(line 12)
			     var parserMock = new Mock();(line 15)
			     ExtensionPointsRepository.Instance.RegisterParserImplementation(new List,parserMock.Object);(line 16)
			     Assert.IsNotNull(ExtensionPointsRepository.Instance.GetParserImplementation(".h"));(line 17)
			     Assert.IsNotNull(ExtensionPointsRepository.Instance.GetParserImplementation(".H"));(line 18)
			     Assert.IsNotNull(ExtensionPointsRepository.Instance.GetParserImplementation(".cpp"));(line 19)
			     Assert.IsNotNull(ExtensionPointsRepository.Instance.GetParserImplementation(".CPP"));(line 20)
			}

 
			public GIVEN_FileLoggerNotInitialize_WHEN_SetupDefautlFileLoggerMethodIsCalled_AND_DefaultLoggerIsUsed_THEN_LogFileShouldBeCreatedAndContainLoggedMessage(){(line 13)
			                 SandoLogManager.StartDefaultLogging(_directoryPath);(line 16)
			                 LogEvents.TestLogging(this);(line 17)
			     var logFiles = Directory.GetFiles(_directoryPath).AsEnumerable().Where().ToList();(line 18)
			     Assert.IsTrue(logFiles.Any(),"There should be log file created!");(line 19)
			     var content = File.ReadAllText(logFiles.First());(line 20)
			     Assert.IsTrue(content.Contains("Message from the logger"),"Invalid log file content");(line 21)
			}

 
			public GIVEN_SolutionFullNameIsNul_WHEN_GetOrCreateLuceneDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 12)
			     var dir = LuceneDirectoryHelper.GetOrCreateLuceneDirectoryForSolution(null,"C:\\lucene");(line 15)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 16)
			}

 
			public GIVEN_SolutionFullNameIsInvalidPath_WHEN_GetOrCreateLuceneDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 19)
			     var dir = LuceneDirectoryHelper.GetOrCreateLuceneDirectoryForSolution("C:\\InvalidDir","C:\\lucene");(line 22)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 23)
			}

 
			public GIVEN_LuceneDirectoryIsNull_WHEN_GetOrCreateLuceneDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 26)
			     var dir = LuceneDirectoryHelper.GetOrCreateLuceneDirectoryForSolution("C:\\InvalidDir",null);(line 29)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 30)
			}

 
			public GIVEN_LuceneDirectoryParentPathIsInvalidPath_WHEN_GetOrCreateLuceneDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 33)
			     var dir = LuceneDirectoryHelper.GetOrCreateLuceneDirectoryForSolution(_solPath,"invalidPath");(line 36)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 37)
			}

 
			public GIVEN_ValidPathAndLuceneDirectory_WHEN_GetOrCreateLuceneDirectoryForSolutionMethodIsCalled_THEN_ValidPathIsReturned(){(line 40)
			     var dir = LuceneDirectoryHelper.GetOrCreateLuceneDirectoryForSolution(_solPath,Path.GetTempPath());(line 43)
			     Assert.IsFalse(String.IsNullOrWhiteSpace(dir),"Directory path must be a non empty string");(line 44)
			     var luceneDirectoryPath = Path.Combine(Path.GetTempPath(),Path.GetTempPath());(line 45)
			     Assert.IsTrue(Directory.Exists(luceneDirectoryPath),"Lucene directory path must be a valid directory path");(line 46)
			     var solutionDirectoryPath = Path.Combine(Path.GetTempPath(),"lucene",Path.GetFileName(dir).ToString(CultureInfo.InvariantCulture));(line 47)
			     Assert.IsTrue(Directory.Exists(solutionDirectoryPath),"Solution lucene directory path must be a valid directory path: " + solutionDirectoryPath);(line 48)
			}

 
			public GIVEN_SolutionFullNameIsNul_WHEN_GetOrCreateSrcMlArchivesDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 51)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution(null,"C:\\lucene");(line 54)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 55)
			}

 
			public GIVEN_SolutionFullNameIsInvalidPath_WHEN_GetOrCreateSrcMlArchivesDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 58)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution("InvalidDir","C:\\srcmlarch");(line 61)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 62)
			}

 
			public GIVEN_LuceneDirectoryIsNull_WHEN_GetOrCreateSrcMlArchivesDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 65)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution("InvalidDir",null);(line 68)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 69)
			}

 
			public GIVEN_LuceneDirectoryParentPathIsInvalidPath_WHEN_GetOrCreateSrcMlArchivesDirectoryForSolutionMethodIsCalled_THEN_EmptyStringIsReturned(){(line 72)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution(_solPath,"invalidPath");(line 75)
			     Assert.AreEqual(String.Empty,dir,"Directory path should be an empty string");(line 76)
			}

 
			public GIVEN_ValidPathAndLuceneDirectory_WHEN_GetOrCreateSrcMlArchivesDirectoryForSolutionMethodIsCalled_THEN_ValidPathIsReturned(){(line 79)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution(_solPath,Path.GetTempPath());(line 82)
			     Assert.IsFalse(String.IsNullOrWhiteSpace(dir),"Directory path must be a non empty string");(line 83)
			     var srcMlArchivesDirectoryPath = Path.Combine(Path.GetTempPath(),Path.GetTempPath());(line 84)
			     Assert.IsTrue(Directory.Exists(srcMlArchivesDirectoryPath),"Lucene directory path must be a valid directory path");(line 85)
			     var solutionDirectoryPath = Path.Combine(Path.GetTempPath(),"srcMlArchives",Path.GetFileName(dir).ToString(CultureInfo.InvariantCulture));(line 86)
			     Assert.IsTrue(Directory.Exists(solutionDirectoryPath),"Solution srcMlArchives directory path must be a valid directory path: " + solutionDirectoryPath);(line 87)
			}

 
			public MakeSureFolderIsHashedOnEntirePath(){(line 90)
			     var dir = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution(_solPath,Path.GetTempPath());(line 93)
			     var dir2 = LuceneDirectoryHelper.GetOrCreateSrcMlArchivesDirectoryForSolution(_solPath2,Path.GetTempPath());(line 94)
			     Assert.AreNotEqual(dir,dir2,"Paths should be different (have a different hash value)\n" + dir + "\n" + dir2);(line 95)
			}

 
			public SearchRespectsAccessLevelCriteriaInternal(){(line 27)
			     var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 30)
			     string keywords = "SingleUsageTypeCriteriaToString";(line 31)
			     SearchCriteria searchCriteria = new SimpleSearchCriteria();(line 32)
			     List<CodeSearchResult> codeSearchResults = codeSearcher.Search(searchCriteria);(line 38)
			     var methodSearchResult = codeSearchResults.Find();(line 39)
			     if(methodSearchResult == null)(line 42)
			         Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 44)
			     var method = methodSearchResult.ProgramElement as MethodElement;(line 47)
			     Assert.AreEqual(method.AccessLevel,AccessLevel.Internal,"Method access level differs!");(line 48)
			     Assert.AreEqual(method.Arguments,"StringBuilder stringBuilder UsageType usageType","Method arguments differs!");(line 49)
			     Assert.NotNull(method.Body,"Method body is null!");(line 50)
			     Assert.AreEqual(method.DefinitionLineNumber,141,"Method definition line number differs!");(line 53)
			     Assert.True(method.FullFilePath.EndsWith("\\TestFiles\\MethodElementTestFiles\\Searcher.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 54)
			     Assert.AreEqual(method.Name,"SingleUsageTypeCriteriaToString","Method name differs!");(line 55)
			     Assert.AreEqual(method.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 56)
			     Assert.AreEqual(method.ReturnType,"void","Method return type differs!");(line 57)
			     Assert.False(String.IsNullOrWhiteSpace(method.RawSource),"Method snippet is invalid!");(line 58)
			}

 
			public SearchRespectsAccessLevelCriteria(){(line 61)
			var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 64)
			         string keywords = "usage type";(line 65)
			         SearchCriteria searchCriteria = new SimpleSearchCriteria();(line 66)
			         List<CodeSearchResult> codeSearchResults = codeSearcher.Search(searchCriteria);(line 72)
			         Assert.AreEqual(2,codeSearchResults.Count,"Invalid results number");(line 73)
			         var methodSearchResult = codeSearchResults.Find();(line 74)
			         if(methodSearchResult == null)(line 77)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 79)
			         var method = methodSearchResult.ProgramElement as MethodElement;(line 81)
			         Assert.AreEqual(method.AccessLevel,AccessLevel.Private,"Method access level differs!");(line 82)
			         Assert.AreEqual(method.Arguments,"StringBuilder stringBuilder bool searchByUsageType","Method arguments differs!");(line 83)
			         Assert.NotNull(method.Body,"Method body is null!");(line 84)
			         Assert.AreEqual(method.DefinitionLineNumber,96,"Method definition line number differs!");(line 87)
			         Assert.True(method.FullFilePath.EndsWith("\\TestFiles\\MethodElementTestFiles\\Searcher.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 88)
			         Assert.AreEqual(method.Name,"UsageTypeCriteriaToString","Method name differs!");(line 89)
			         Assert.AreEqual(method.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 90)
			         Assert.AreEqual(method.ReturnType,"void","Method return type differs!");(line 91)
			         Assert.False(String.IsNullOrWhiteSpace(method.RawSource),"Method snippet is invalid!");(line 92)
			}

 
			public SearchWorksNormallyForTermsWhichEndsWithSpace(){(line 97)
			         try(line 100)
			                 var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 102)
			                 string keywords = "  usage ";(line 103)
			                 List<CodeSearchResult> codeSearchResults = codeSearcher.Search(keywords);(line 104)
			         catch(Exception ex)(line 106)
			                 Assert.Fail(ex.Message);(line 108)
			}

 
			public SearchReturnsElementsUsingCrossFieldMatching(){(line 112)
			         var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 115)
			         string keywords = "fetch output argument";(line 116)
			         SearchCriteria searchCriteria = new SimpleSearchCriteria();(line 117)
			         List<CodeSearchResult> codeSearchResults = codeSearcher.Search(searchCriteria);(line 121)
			         var methodSearchResult = codeSearchResults.Find();(line 123)
			         if(methodSearchResult == null)(line 126)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 128)
			         var method = methodSearchResult.ProgramElement as MethodElement;(line 130)
			         Assert.AreEqual(method.AccessLevel,AccessLevel.Public,"Method access level differs!");(line 131)
			         Assert.AreEqual(method.Arguments,"A B string fileName Image image","Method arguments differs!");(line 132)
			         Assert.NotNull(method.Body,"Method body is null!");(line 133)
			         Assert.True(method.ClassId != null && method.ClassId != Guid.Empty,"Class id is invalid!");(line 134)
			Assert.AreEqual(method.ClassName,"ImageCapture","Method class name differs!");(line 135)
			         Assert.AreEqual(method.DefinitionLineNumber,83,"Method definition line number differs!");(line 136)
			Assert.True(method.FullFilePath.EndsWith("\\TestFiles\\MethodElementTestFiles\\ImageCapture.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 137)
			         Assert.AreEqual(method.Name,"FetchOutputStream","Method name differs!");(line 138)
			         Assert.AreEqual(method.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 139)
			         Assert.AreEqual(method.ReturnType,"void","Method return type differs!");(line 140)
			         Assert.False(String.IsNullOrWhiteSpace(method.RawSource),"Method snippet is invalid!");(line 141)
			}

 
			public ExactLexMatchSearch1(){(line 24)
			string keywords = "LexicalSelfSearchTest";(line 26)
			     var expectedLowestRank = 1;(line 27)
			         Predicate<CodeSearchResult> predicate;(line 28)
			         EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 29)
			}

 
			public ExactLexMatchSearch2(){(line 32)
			     string keywords = "lexicalselfsearchtest";(line 35)
			     var expectedLowestRank = 1;(line 36)
			     Predicate<CodeSearchResult> predicate;(line 37)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 38)
			}

 
			public ExactLexMatchSearch3(){(line 41)
			     string keywords = "LexicalSelf";(line 44)
			     var expectedLowestRank = 1;(line 45)
			     Predicate<CodeSearchResult> predicate;(line 46)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 47)
			}

 
			public PreferenceForShortestMatch(){(line 71)
			     string keywords = "Pumpkin";(line 74)
			     var expectedLowestRank = 2;(line 75)
			     Predicate<CodeSearchResult> predicate;(line 76)
			     List<CodeSearchResult> results = EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 77)
			     Assert.IsTrue(results.Count >= 3);(line 78)
			     Assert.IsTrue(results[0].Score > results[1].Score);(line 79)
			     Assert.IsTrue(results[0].Score > results[2].Score);(line 80)
			}

 
			public QuotedExactQueryTest(){(line 110)
			string keywords = "\"private static void InitDte2()\"";(line 113)
			var expectedLowestRank = 4;(line 114)
			Predicate<CodeSearchResult> predicate;(line 115)
			List<CodeSearchResult> results = EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 116)
			}

 
			public QuotedExactQueryWithQuotesInItMindBlownTest(){(line 122)
			     string keywords = "\"Assert.IsNotNull(wordSplitter, \\\"Default word splitter should x used!!\\\");\"";(line 125)
			     var expectedLowestRank = 3;(line 126)
			     Predicate<CodeSearchResult> predicate;(line 127)
			     List<CodeSearchResult> results = EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 128)
			}

 
			public MethodElementReturnedFromSearchContainsAllFields(){(line 30)
			var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 33)
			         string keywords = "fetch output stream";(line 34)
			         List<CodeSearchResult> codeSearchResults = codeSearcher.Search(keywords);(line 35)
			         Assert.AreEqual(codeSearchResults.Count,5,"Invalid results number");(line 36)
			         var methodSearchResult = codeSearchResults.Find();(line 37)
			         if(methodSearchResult == null)(line 38)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 40)
			         var method = methodSearchResult.ProgramElement as MethodElement;(line 42)
			         Assert.AreEqual(method.AccessLevel,AccessLevel.Public,"Method access level differs!");(line 43)
			         Assert.AreEqual(method.Arguments,"A B string fileName Image image","Method arguments differs!");(line 44)
			         Assert.NotNull(method.Body,"Method body is null!");(line 45)
			         Assert.True(method.ClassId != null && method.ClassId != Guid.Empty,"Class id is invalid!");(line 46)
			Assert.AreEqual(method.ClassName,"ImageCapture","Method class name differs!");(line 47)
			         Assert.AreEqual(method.DefinitionLineNumber,83,"Method definition line number differs!");(line 48)
			Assert.True(method.FullFilePath.EndsWith("\\TestFiles\\MethodElementTestFiles\\ImageCapture.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 49)
			         Assert.AreEqual(method.Name,"FetchOutputStream","Method name differs!");(line 50)
			         Assert.AreEqual(method.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 51)
			         Assert.AreEqual(method.ReturnType,"void","Method return type differs!");(line 52)
			         Assert.False(String.IsNullOrWhiteSpace(method.RawSource),"Method snippet is invalid!");(line 53)
			}

 
			public MethodSearchRespectsAccessLevelCriteria(){(line 56)
			var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 59)
			         string keywords = "to string";(line 60)
			         SearchCriteria searchCriteria = new SimpleSearchCriteria();(line 61)
			         List<CodeSearchResult> codeSearchResults = codeSearcher.Search(searchCriteria);(line 67)
			         Assert.AreEqual(7,codeSearchResults.Count,"Invalid results number");(line 68)
			         var methodSearchResult = codeSearchResults.Find();(line 69)
			         if(methodSearchResult == null)(line 70)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 72)
			         var method = methodSearchResult.ProgramElement as MethodElement;(line 74)
			         Assert.AreEqual(method.AccessLevel,AccessLevel.Public,"Method access level differs!");(line 75)
			         Assert.AreEqual(method.Arguments,String.Empty,"Method arguments differs!");(line 76)
			         Assert.NotNull(method.Body,"Method body is null!");(line 77)
			         Assert.True(method.ClassId != null && method.ClassId != Guid.Empty,"Class id is invalid!");(line 78)
			Assert.AreEqual(method.ClassName,"SimpleSearchCriteria","Method class name differs!");(line 79)
			         Assert.AreEqual(method.DefinitionLineNumber,31,"Method definition line number differs!");(line 80)
			Assert.True(method.FullFilePath.EndsWith("\\TestFiles\\MethodElementTestFiles\\Searcher.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 81)
			         Assert.AreEqual(method.Name,"ToQueryString","Method name differs!");(line 82)
			         Assert.AreEqual(method.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 83)
			         Assert.AreEqual(method.ReturnType,"void","Method return type differs!");(line 84)
			         Assert.False(String.IsNullOrWhiteSpace(method.RawSource),"Method snippet is invalid!");(line 85)
			}

 
			public MethodSearchRespectsFileExtensionsCriteria(){(line 88)
			     var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 91)
			     var keywords = "main";(line 92)
			     var searchCriteria = new SimpleSearchCriteria();(line 93)
			     var codeSearchResults = codeSearcher.Search(searchCriteria);(line 99)
			     Assert.AreEqual(1,codeSearchResults.Count,"Invalid results number");(line 100)
			     var methodSearchResult = codeSearchResults.Find();(line 101)
			     if(methodSearchResult == null)(line 102)
			         Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 104)
			}

 
			public CloseAndReopen(){(line 15)
			     var indexer = ServiceLocator.Resolve<DocumentIndexer>();(line 18)
			     indexer.Dispose();(line 19)
			     var currentIndexer = new DocumentIndexer(TimeSpan.FromSeconds(10),GetTimeToCommit());(line 20)
			     ServiceLocator.RegisterInstance(currentIndexer);(line 21)
			     Assert.IsTrue(currentIndexer.GetNumberOfIndexedDocuments() > 5,"The index is being destroyed when it is closed and reopened");(line 22)
			}

 
			public TestStemmingForMetricsCalculation(){(line 18)
			     var documentIndexer = ServiceLocator.Resolve<DocumentIndexer>();(line 21)
			     var analyzer = ServiceLocator.Resolve<Analyzer>();(line 22)
			     PreRetrievalMetrics preMetrics = new PreRetrievalMetrics(documentIndexer.Reader,analyzer);(line 24)
			     Assert.AreEqual(preMetrics.StemText("searching"),"search");(line 25)
			     Assert.AreEqual(preMetrics.StemText("search"),"search");(line 26)
			     Assert.AreEqual(preMetrics.StemText("solution closing"),"solut close");(line 27)
			     Assert.AreEqual(preMetrics.StemText("indexer"),"index");(line 28)
			}

 
			public TestSpecificityMetrics(){(line 31)
			     var documentIndexer = ServiceLocator.Resolve<DocumentIndexer>();(line 34)
			     var analyzer = ServiceLocator.Resolve<Analyzer>();(line 35)
			     PreRetrievalMetrics preMetrics = new PreRetrievalMetrics(documentIndexer.Reader,analyzer);(line 37)
			     Assert.IsTrue(preMetrics.AvgIdf("splitting") > preMetrics.AvgIdf("searching"));(line 38)
			     Assert.IsTrue(preMetrics.AvgIdf("solution closing") > preMetrics.AvgIdf("indexer"));(line 39)
			}

 
			public TestSimilarityMetrics(){(line 42)
			     var documentIndexer = ServiceLocator.Resolve<DocumentIndexer>();(line 45)
			     var analyzer = ServiceLocator.Resolve<Analyzer>();(line 46)
			     PreRetrievalMetrics preMetrics = new PreRetrievalMetrics(documentIndexer.Reader,analyzer);(line 48)
			     Assert.IsTrue(preMetrics.AvgSqc("indexer") > preMetrics.AvgSqc("potato chip"));(line 49)
			     Assert.IsTrue(preMetrics.AvgSqc("indexer") > preMetrics.AvgSqc("soda pop"));(line 50)
			}

 
			public FindBodyText(){(line 27)
			     string keywords = "document add";(line 30)
			     var expectedLowestRank = 10;(line 31)
			     Predicate<CodeSearchResult> predicate;(line 32)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 33)
			}

 
			public QuotedSearchNoResults(){(line 37)
			     string keywords = "\"frigging" + "NoResultsMahn\"";(line 40)
			     var expectedLowestRank = 0;(line 41)
			     Predicate<CodeSearchResult> predicate;(line 42)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 43)
			     Assert.IsTrue(_myMessage.Contains("No results"));(line 44)
			}

 
			public QuotedNoQuotesWithQuotesInside(){(line 47)
			     string keywords = "\"return \\\"..\\\\\\\\..\\\\\\\\Parser\\\";\"";(line 50)
			     var expectedLowestRank = 5;(line 51)
			     Predicate<CodeSearchResult> predicate;(line 52)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 53)
			}

 
			public QueryShouldGetSomeResults(){(line 58)
			     string keywords = "\"Debug.WriteLine(string.Format(\"{0}:\\t{1}\\t{2}\\t{3}\\t{4}\",\"";(line 61)
			     var expectedLowestRank = 20;(line 62)
			     Predicate<CodeSearchResult> predicate;(line 63)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 64)
			}

 
			public QuotedSearchWithNot(){(line 69)
			     string keywords = "\"Search(\" -test";(line 74)
			     var expectedLowestRank = 2;(line 75)
			}

 
			public QuotedSearchBroken(){(line 81)
			     string keywords = "\"ServiceLocator.Resolve<DTE2>();\"";(line 84)
			     var expectedLowestRank = 10;(line 85)
			     Predicate<CodeSearchResult> predicate;(line 86)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 87)
			}

 
			public QuotedWithoutQuotes(){(line 90)
			     string keywords = "ServiceLocator.Resolve<DTE2>();";(line 93)
			     var expectedLowestRank = 10;(line 94)
			     Predicate<CodeSearchResult> predicate;(line 95)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 96)
			}

 
			public QuotedSearchWithSpacesBroken(){(line 99)
			     string keywords = "\"foreach (var term in SearchTerms)\"";(line 102)
			     var expectedLowestRank = 10;(line 103)
			     Predicate<CodeSearchResult> predicate;(line 104)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 105)
			}

 
			public ExcludeTestIfClassNameHasTest(){(line 108)
			     string keywords = "reorder search results -test";(line 111)
			     var expectedLowestRank = 20;(line 112)
			     try(line 113)
			         Predicate<CodeSearchResult> predicate;(line 114)
			         EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 115)
			      catch(Exception e)(line 116)
			         return ;(line 118)
			     Assert.IsTrue(false,"Should fail to find this method " + PrintFailInformation(false));(line 120)
			}

 
			public ElementNameSearchesInTop3(){(line 123)
			string keywords = "header element resolver cpp";(line 126)
			     var expectedLowestRank = 3;(line 127)
			         Predicate<CodeSearchResult> predicate;(line 128)
			         EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 129)
			}

 
			public UnderscoreSearch(){(line 132)
			     string keywords = "solutionEvents";(line 135)
			     var expectedLowestRank = 6;(line 136)
			     Predicate<CodeSearchResult> predicate;(line 137)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 138)
			     keywords = "_solutionEvents";(line 139)
			     predicate =;(line 140)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 141)
			}

 
			public FileTypeWithTerm(){(line 145)
			     string keywords = "hello world file:cpp";(line 148)
			     var expectedLowestRank = 2;(line 149)
			     Predicate<CodeSearchResult> predicate;(line 150)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 151)
			}

 
			public FileTypeH(){(line 154)
			     string keywords = "session file info file:h";(line 157)
			     var expectedLowestRank = 3;(line 158)
			     Predicate<CodeSearchResult> predicate;(line 159)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 160)
			}

 
			public FileTypeSearch(){(line 163)
			     string keywords = "XmlMatchedTagsHighlighter filetype:cs";(line 166)
			     var expectedLowestRank = 10;(line 167)
			     try(line 168)
			         Predicate<CodeSearchResult> predicate;(line 170)
			         EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 171)
			         Assert.IsTrue(false,"Should never reach this point. If it does, then it is finding a .cpp file when searching for only cs files");(line 172)
			     catch(Exception e)(line 174)
			}

 
			public TestSandoSearch(){(line 180)
			 string keywords = "test sando search";(line 183)
			 var expectedLowestRank = 3;(line 184)
			 Predicate<CodeSearchResult> predicate;(line 185)
			 EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 186)
			}

 
			public TestNoteSandoSearch(){(line 189)
			     string keywords = "-test sando search";(line 192)
			     var expectedLowestRank = 10;(line 193)
			     Predicate<CodeSearchResult> predicate;(line 194)
			     var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 195)
			     List<CodeSearchResult> codeSearchResults = codeSearcher.Search(keywords);(line 196)
			     var methodSearchResult = codeSearchResults.Find(predicate);(line 197)
			     if(methodSearchResult != null)(line 198)
			         Assert.Fail("Should not find anything that matches for this test: " + keywords);(line 200)
			}

 
			public TestSolutionOpened(){(line 205)
			     string keywords = "RespondToSolutionOpened";(line 208)
			     var expectedLowestRank = 2;(line 209)
			     Predicate<CodeSearchResult> predicate;(line 210)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 211)
			}

 
			public TestSeveralSearchesOnSandoCodeBase(){(line 214)
			     string keywords = "parse method";(line 217)
			     var expectedLowestRank = 2;(line 218)
			     Predicate<CodeSearchResult> predicate;(line 219)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 220)
			     keywords = "parse class";(line 221)
			     expectedLowestRank = 2;(line 222)
			     predicate =;(line 223)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 224)
			     keywords = "parse util";(line 225)
			     expectedLowestRank = 3;(line 226)
			     predicate =;(line 227)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 228)
			     keywords = "custom properties";(line 229)
			     expectedLowestRank = 2;(line 230)
			     predicate =;(line 231)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 232)
			     keywords = "ParserException";(line 237)
			     expectedLowestRank = 2;(line 238)
			     predicate =;(line 239)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 240)
			     keywords = "word extract";(line 241)
			     expectedLowestRank = 1;(line 242)
			     predicate =;(line 243)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 244)
			     keywords = "translation get";(line 245)
			     expectedLowestRank = 3;(line 246)
			     predicate =;(line 247)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 248)
			     keywords = "RegisterExtensionPoints";(line 249)
			     expectedLowestRank = 3;(line 250)
			     predicate =;(line 251)
			     EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 252)
			}

 
			public SearchIsUsingStemming(){(line 26)
			var codeSearcher = new CodeSearcher(new IndexerSearcher());(line 29)
			         string keywords = "name";(line 30)
			         List<CodeSearchResult> codeSearchResults = codeSearcher.Search(keywords);(line 31)
			         Assert.AreEqual(codeSearchResults.Count,8,"Invalid results number");(line 32)
			var classSearchResult = codeSearchResults.Find();(line 33)
			         if(classSearchResult == null)(line 34)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 36)
			         var classElement = classSearchResult.ProgramElement as ClassElement;(line 38)
			         Assert.AreEqual(classElement.AccessLevel,AccessLevel.Public,"Class access level differs!");(line 39)
			         Assert.AreEqual(classElement.ExtendedClasses,String.Empty,"Class extended classes differs!");(line 40)
			         Assert.AreEqual(classElement.DefinitionLineNumber,10,"Class definition line number differs!");(line 41)
			Assert.True(classElement.FullFilePath.EndsWith("\\TestFiles\\StemmingTestFiles\\FileNameTemplate.cs".ToLowerInvariant()),"Class full file path is invalid!");(line 42)
			         Assert.AreEqual(classElement.Name,"FileNameTemplate","Class name differs!");(line 43)
			         Assert.AreEqual(classElement.ProgramElementType,ProgramElementType.Class,"Program element type differs!");(line 44)
			         Assert.AreEqual(classElement.ImplementedInterfaces,String.Empty,"Class implemented interfaces differs!");(line 45)
			         Assert.False(String.IsNullOrWhiteSpace(classElement.RawSource),"Class snippet is invalid!");(line 46)
			         var methodSearchResult = codeSearchResults.Find();(line 48)
			         if(methodSearchResult == null)(line 49)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 51)
			         var methodElement = methodSearchResult.ProgramElement as MethodElement;(line 53)
			         Assert.AreEqual(methodElement.AccessLevel,AccessLevel.Public,"Method access level differs!");(line 54)
			         Assert.AreEqual(methodElement.Arguments,"string extension","Method arguments differs!");(line 55)
			         Assert.NotNull(methodElement.Body,"Method body is null!");(line 56)
			         Assert.True(methodElement.ClassId != null && methodElement.ClassId != Guid.Empty,"Class id is invalid!");(line 57)
			         Assert.AreEqual(methodElement.ClassName,"FileNameTemplate","Method class name differs!");(line 58)
			         Assert.AreEqual(methodElement.DefinitionLineNumber,17,"Method definition line number differs!");(line 59)
			Assert.True(methodElement.FullFilePath.EndsWith("\\TestFiles\\StemmingTestFiles\\FileNameTemplate.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 60)
			         Assert.AreEqual(methodElement.Name,"Parse","Method name differs!");(line 61)
			         Assert.AreEqual(methodElement.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 62)
			         Assert.AreEqual(methodElement.ReturnType,"ImagePairNames","Method return type differs!");(line 63)
			         Assert.False(String.IsNullOrWhiteSpace(methodElement.RawSource),"Method snippet is invalid!");(line 64)
			         methodSearchResult = codeSearchResults.Find();(line 66)
			         if(methodSearchResult == null)(line 67)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 69)
			         methodElement = methodSearchResult.ProgramElement as MethodElement;(line 71)
			         Assert.AreEqual(methodElement.AccessLevel,AccessLevel.Private,"Method access level differs!");(line 72)
			         Assert.AreEqual(methodElement.Arguments,"ImagePairNames startNames","Method arguments differs!");(line 73)
			         Assert.NotNull(methodElement.Body,"Method body is null!");(line 74)
			         Assert.True(methodElement.ClassId != null && methodElement.ClassId != Guid.Empty,"Class id is invalid!");(line 75)
			Assert.AreEqual(methodElement.ClassName,"FileNameTemplate","Method class name differs!");(line 76)
			         Assert.AreEqual(methodElement.DefinitionLineNumber,53,"Method definition line number differs!");(line 77)
			Assert.True(methodElement.FullFilePath.EndsWith("\\TestFiles\\StemmingTestFiles\\FileNameTemplate.cs".ToLowerInvariant()),"Method full file path is invalid!");(line 78)
			         Assert.AreEqual(methodElement.Name,"TryAddTemplatePrompt","Method name differs!");(line 79)
			         Assert.AreEqual(methodElement.ProgramElementType,ProgramElementType.Method,"Program element type differs!");(line 80)
			         Assert.False(String.IsNullOrWhiteSpace(methodElement.RawSource),"Method snippet is invalid!");(line 82)
			         var fieldSearchResult = codeSearchResults.Find();(line 84)
			         if(fieldSearchResult == null)(line 85)
			                 Assert.Fail("Failed to find relevant search result for search: " + keywords);(line 87)
			         var fieldElement = fieldSearchResult.ProgramElement as FieldElement;(line 89)
			         Assert.AreEqual(fieldElement.AccessLevel,AccessLevel.Private,"Field access level differs!");(line 90)
			         Assert.True(fieldElement.ClassId != null && methodElement.ClassId != Guid.Empty,"Class id is invalid!");(line 91)
			Assert.AreEqual(fieldElement.ClassName,"FileNameTemplate","Field class name differs!");(line 92)
			         Assert.AreEqual(fieldElement.DefinitionLineNumber,12,"Field definition line number differs!");(line 93)
			Assert.True(fieldElement.FullFilePath.EndsWith("\\TestFiles\\StemmingTestFiles\\FileNameTemplate.cs".ToLowerInvariant()),"Field full file path is invalid!");(line 94)
			         Assert.AreEqual(fieldElement.Name,"fileName","Field name differs!");(line 95)
			         Assert.AreEqual(fieldElement.ProgramElementType,ProgramElementType.Field,"Program element type differs!");(line 96)
			         Assert.AreEqual(fieldElement.FieldType,"string","Field return type differs!");(line 97)
			         Assert.False(String.IsNullOrWhiteSpace(methodElement.RawSource),"Field snippet is invalid!");(line 98)
			}

 
			public FieldSearchWithUnderscore(){(line 25)
			string keywords = "_solutionKey";(line 28)
			     var expectedLowestRank = 2;(line 29)
			Predicate<CodeSearchResult> predicate;(line 30)
			         EnsureRankingPrettyGood(keywords,predicate,expectedLowestRank);(line 31)
			}

 
			public TestMethod1(){(line 39)
			     MessageBox.Show("hihi");(line 43)
			}

 
			public SearchTest(){(line 61)
			     Assert.IsTrue(TestHelpers.WaitForServiceToFinish(TestHelpers.SrcMLTestScaffold.Service,5000));(line 65)
			     try(line 66)
			         var results = TestHelpers.TestScaffold.Service.GetSearchResults("game pad");(line 68)
			         Assert.IsTrue(results.Count > 0,"Did not find any results when I should have");(line 69)
			         Assert.IsTrue(results.First().Name.Equals("GamePadNode"),"Didn't find fthe correct first result, found: " + results.First().Name);(line 70)
			     catch(Exception e)(line 72)
			         Assert.IsTrue(false,"Search failed with an exception: " + e.Message);(line 74)
			}

 
			public RecommendationsTest(){(line 78)
			     Assert.IsTrue(TestHelpers.WaitForServiceToFinish(TestHelpers.SrcMLTestScaffold.Service,5000));(line 82)
			     try(line 83)
			         var recommender = ServiceLocator.Resolve<QueryRecommender>();(line 85)
			         Assert.IsTrue(recommender.GenerateRecommendations("play").Length > 0,"Did not find any recommendations when I should have");(line 86)
			         Assert.IsTrue(recommender.GenerateRecommendations("play").Query.Equals("Player"),"Didn't find the correct first result, found: " + recommender.GenerateRecommendations("game").Query);(line 87)
			     catch(Exception e)(line 89)
			         Assert.IsTrue(false,"Search failed with an exception: " + e.Message);(line 91)
			}

 
			public SummarizationTest(){(line 95)
			     Assert.IsTrue(TestHelpers.WaitForServiceToFinish(TestHelpers.SrcMLTestScaffold.Service,10000));(line 99)
			     var firstResult = TestHelpers.TestScaffold.Service.GetSearchResults("pc player game").First();(line 100)
			     var control = ServiceLocator.Resolve<SearchViewControl>();(line 101)
			     string highlight;(line 102)
			     string highlightRaw;(line 103)
			     control.GenerateHighlight(firstResult.Raw,"play",highlight,highlightRaw);(line 104)
			     Assert.IsTrue(highlight.Contains("public PC|~S~|Play|~E~|er PC|~S~|Play|~E~|er"));(line 107)
			     Assert.IsFalse(highlight.Contains("get"));(line 108)
			     Assert.IsTrue(highlight.Contains("return pc|~S~|Play|~E~|er;"));(line 110)
			}

 
			public SplitTest(){(line 11)
			     var splitter = new CamelIdSplitter();(line 13)
			     var actual = splitter.Split("DBGetHydro");(line 14)
			     var expected = new;(line 15)
			     Assert.AreEqual(expected,actual);(line 16)
			}

 
			public SplitTest_lowercase(){(line 19)
			     var splitter = new CamelIdSplitter();(line 21)
			     var actual = splitter.Split("lowercase");(line 22)
			     var expected = new;(line 23)
			     Assert.AreEqual(expected,actual);(line 24)
			}

 
			public SplitTest_uppercase(){(line 27)
			     var splitter = new CamelIdSplitter();(line 29)
			     var actual = splitter.Split("CONSTVAL");(line 30)
			     var expected = new;(line 31)
			     Assert.AreEqual(expected,actual);(line 32)
			}

 
			public SplitTest_UppercaseUnderscore(){(line 35)
			     var splitter = new CamelIdSplitter();(line 37)
			     var actual = splitter.Split("CONST_VAL");(line 38)
			     var expected = new;(line 39)
			     Assert.AreEqual(expected,actual);(line 40)
			}

 
			public SplitTest_BadCamelCase(){(line 43)
			     var splitter = new CamelIdSplitter();(line 45)
			     var actual = splitter.Split("XMLparser");(line 46)
			     var expected = new;(line 47)
			     Assert.AreEqual(expected,actual);(line 48)
			}

 
			public TestRoundTrip(){(line 13)
			     var a1 = new WordNode("DB",PartOfSpeechTag.Preamble);(line 15)
			     var a2 = new WordNode("Get",PartOfSpeechTag.Verb);(line 16)
			     var t1 = new WordNode("Hydro",PartOfSpeechTag.NounModifier);(line 17)
			     var t2 = new WordNode("Fixed",PartOfSpeechTag.NounModifier);(line 18)
			     var t3 = new WordNode("Schedule",PartOfSpeechTag.Noun);(line 19)
			     var sdr = new SwumDataRecord();(line 21)
			     sdr.ParsedAction = new PhraseNode(new,Location.None,false);(line 22)
			     sdr.Action = sdr.ParsedAction.ToPlainString();(line 23)
			     sdr.ParsedTheme = new PhraseNode(new,Location.None,false);(line 24)
			     sdr.Theme = sdr.ParsedTheme.ToPlainString();(line 25)
			     var actual = SwumDataRecord.Parse(sdr.ToString());(line 27)
			     Assert.IsTrue(SwumDataRecordsAreEqual(sdr,actual));(line 28)
			}

 
			public QueryRecommenderTest(){(line 31)
			     Assert.IsTrue(int(10 / QueryRecommender.Distance("Add","findAndAddRelevantFilesToIndexState")) < int(10 / QueryRecommender.Distance("Add","addError")));(line 34)
			     Assert.IsTrue(QueryRecommender.Distance("AddFiles","Add") < QueryRecommender.Distance("AddFiles","AddAndDoOtherStuff"));(line 35)
			     Assert.IsTrue(QueryRecommender.Distance("AddFiles","AddFile") < QueryRecommender.Distance("AddFiles","AddFilesYeah"));(line 36)
			     Assert.IsTrue(QueryRecommender.Distance("Add","AddFilesAndDoStuff") < QueryRecommender.Distance("Add","FilesAndDoStuffAdd"));(line 37)
			}

 
			public TestRoundTrip_FileNames(){(line 40)
			     var a1 = new WordNode("DB",PartOfSpeechTag.Preamble);(line 42)
			     var a2 = new WordNode("Get",PartOfSpeechTag.Verb);(line 43)
			     var t1 = new WordNode("Hydro",PartOfSpeechTag.NounModifier);(line 44)
			     var t2 = new WordNode("Fixed",PartOfSpeechTag.NounModifier);(line 45)
			     var t3 = new WordNode("Schedule",PartOfSpeechTag.Noun);(line 46)
			     var f1 = @"C:\foo\bar.cpp";(line 47)
			     var f2 = @"C:\foo\baz\xyzzy.h";(line 48)
			     var f3 = "test.cpp";(line 49)
			     var sdr = new SwumDataRecord();(line 51)
			     sdr.ParsedAction = new PhraseNode(new,Location.None,false);(line 52)
			     sdr.Action = sdr.ParsedAction.ToPlainString();(line 53)
			     sdr.ParsedTheme = new PhraseNode(new,Location.None,false);(line 54)
			     sdr.Theme = sdr.ParsedTheme.ToPlainString();(line 55)
			     sdr.FileNames.Add(f1);(line 56)
			     sdr.FileNames.Add(f2);(line 57)
			     sdr.FileNames.Add(f3);(line 58)
			     var actual = SwumDataRecord.Parse(sdr.ToString());(line 60)
			     Assert.IsTrue(SwumDataRecordsAreEqual(sdr,actual));(line 61)
			}

 
			public TestReadingRealCache(){(line 28)
			     manager.ReadSwumCache(@"..\..\Recommender\Recommender.UnitTests\TestFiles\swum-cache.txt");(line 31)
			     var datas = manager.GetSwumData();(line 32)
			     Assert.IsTrue(datas.Count > 400);(line 33)
			     foreach(var data)(line 34)
			         Assert.IsTrue(data.Value.SwumNode != null);(line 35)
			}

 
			public TestCacheRoundTrip(){(line 38)
			     manager.AddSrcMLFile(SrcMLElement.Load(@"TestFiles\json_reader.cpp.xml"));(line 40)
			     int beforeCount = manager.GetSwumData().Count;(line 41)
			     string tempFile = "swum_cache.txt";(line 43)
			     manager.PrintSwumCache(tempFile);(line 44)
			     manager.ReadSwumCache(tempFile);(line 45)
			     Assert.AreEqual(beforeCount,manager.GetSwumData().Count);(line 46)
			}

 
			public TestAddSourceFile(){(line 50)
			     Assert.IsFalse(manager.GetSwumData().Any());(line 52)
			     manager.AddSourceFile(@"TestFiles\small_json_reader.cpp");(line 53)
			     Assert.AreEqual(5,manager.GetSwumData().Keys.Count);(line 54)
			     Assert.IsNotNull(manager.GetSwumForSignature("static bool containsNewLine( Reader::Location begin, Reader::Location end )"));(line 55)
			     Assert.IsNotNull(manager.GetSwumForSignature("static std::string codePointToUTF8(unsigned int cp)"));(line 56)
			     Assert.IsNotNull(manager.GetSwumForSignature("Reader::Reader()"));(line 57)
			     Assert.IsNotNull(manager.GetSwumForSignature("bool Reader::parse( const std::string &document, Value &root, bool collectComments )"));(line 58)
			     Assert.IsNotNull(manager.GetSwumForSignature("bool Reader::parse( std::istream& sin, Value &root, bool collectComments )"));(line 59)
			}

 
			public TestAddSourceFile_DoubleExtension(){(line 62)
			     Assert.IsFalse(manager.GetSwumData().Any());(line 64)
			     manager.AddSourceFile(@"TestFiles\small_json.reader.cpp");(line 65)
			     Assert.AreEqual(5,manager.GetSwumData().Keys.Count);(line 66)
			     Assert.IsNotNull(manager.GetSwumForSignature("static bool containsNewLine( Reader::Location begin, Reader::Location end )"));(line 67)
			     Assert.IsNotNull(manager.GetSwumForSignature("static std::string codePointToUTF8(unsigned int cp)"));(line 68)
			     Assert.IsNotNull(manager.GetSwumForSignature("Reader::Reader()"));(line 69)
			     Assert.IsNotNull(manager.GetSwumForSignature("bool Reader::parse( const std::string &document, Value &root, bool collectComments )"));(line 70)
			     Assert.IsNotNull(manager.GetSwumForSignature("bool Reader::parse( std::istream& sin, Value &root, bool collectComments )"));(line 71)
			}

 
			public TestAddSourceFile_CSharp_Property(){(line 74)
			     Assert.IsFalse(manager.GetSwumData().Any());(line 76)
			     manager.AddSourceFile(@"TestFiles\CSharp_with_property.cs");(line 77)
			     Assert.AreEqual(3,manager.GetSwumData().Keys.Count);(line 78)
			     Assert.IsNotNull(manager.GetSwumForSignature("public TestClass()"));(line 79)
			     Assert.IsNotNull(manager.GetSwumForSignature("public void DoStuff(string theStuff, int count)"));(line 80)
			     Assert.IsNotNull(manager.GetSwumForSignature("private int PrivateStuff(int count)"));(line 81)
			}

 
			public TestRemoveSourceFile(){(line 84)
			     manager.AddSourceFile(@"TestFiles\small_json_reader.cpp");(line 86)
			     manager.AddSourceFile(@"TestFiles\function_def.cpp");(line 87)
			     Assert.IsNotNull(manager.GetSwumForSignature("char* MyFunction(int foo)"));(line 88)
			     manager.RemoveSourceFile(@"TestFiles\function_def.cpp");(line 89)
			     Assert.IsNull(manager.GetSwumForSignature("char* MyFunction(int foo)"));(line 90)
			}

 
			public TestUpdateSourceFile(){(line 93)
			     File.Copy(@"TestFiles\function_def.cpp",@"TestFiles\SwumUpdateTest.cpp",true);(line 95)
			     manager.AddSourceFile(@"TestFiles\SwumUpdateTest.cpp");(line 96)
			     Assert.AreEqual(2,manager.GetSwumData().Count);(line 97)
			     Assert.IsNotNull(manager.GetSwumForSignature("char* MyFunction(int foo)"));(line 98)
			     File.Copy(@"TestFiles\function_def2.cpp",@"TestFiles\SwumUpdateTest.cpp",true);(line 100)
			     manager.UpdateSourceFile(@"TestFiles\SwumUpdateTest.cpp");(line 101)
			     Assert.AreEqual(2,manager.GetSwumData().Count);(line 102)
			     Assert.IsNull(manager.GetSwumForSignature("char* MyFunction(int foo)"));(line 103)
			     Assert.IsNotNull(manager.GetSwumForSignature("char* UpdatedMyFunction(int foo)"));(line 104)
			     File.Delete(@"TestFiles\SwumUpdateTest.cpp");(line 106)
			}

 
			public TestConcurrentReadWrite(){(line 109)
			     manager.AddSourceFile(@"TestFiles\json_reader.cpp");(line 111)
			     Thread addThread = new Thread(AddSourceFiles);(line 112)
			     addThread.Start();(line 113)
			     foreach(var sig)(line 114)
			         Console.WriteLine("From file {0}, found sig: {1}",sig.Value.FileNames.FirstOrDefault(),sig.Key);(line 115)
			     addThread.Join(5000);(line 117)
			}