public void indexer_string_getWhenSynonym() { const string expected = "Foo"; var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add(expected).Synonyms.Add("Bar"); var actual = obj["Bar"].CanonicalForm; Assert.Same(expected, actual); }
public void op_MatchBeginning() { var lexicon = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { "Blenheim Gate" }; var actual = lexicon.MatchBeginning("Blenheim Gate 22-24"); Assert.NotNull(actual); }
public virtual LexicalCollection LoadHierarchy(INormalityComparer comparer) { Trace.WriteIf(Tracing.Is.TraceVerbose, string.Empty); var result = new LexicalCollection(comparer); foreach (var file in Hierarchy) { Load(result, file); } return(result); }
public void op_Add_LexicalItem() { const string expected = "Example"; var obj = new LexicalCollection(NormalityComparer.Ordinal) { new LexicalItem(NormalityComparer.CurrentCulture, expected) }; var actual = obj.First().CanonicalForm; Assert.Equal(expected, actual); }
public void indexer_string_get() { const string expected = "Example"; var obj = new LexicalCollection(NormalityComparer.Ordinal) { expected }; var actual = obj[expected].CanonicalForm; Assert.Same(expected, actual); }
private static void Load(LexicalCollection lexicon, FileInfo file) { foreach (var data in new CsvDataSheet(file)) { var canonical = data["CANONICAL"]; var item = lexicon[canonical] ?? lexicon.Add(canonical); #if NET20 foreach (var synonym in StringExtensionMethods.Split(data["SYNONYMS"], ';', StringSplitOptions.RemoveEmptyEntries)) #else foreach (var synonym in data["SYNONYMS"].Split(';', StringSplitOptions.RemoveEmptyEntries)) #endif { item.Synonyms.Add(synonym); } } }
public void op_MoveTo_Lexicon_LexicalItem() { const string expected = "Example"; var source = new LexicalCollection(NormalityComparer.Ordinal); var item = source.Add(expected); var destination = new LexicalCollection(NormalityComparer.Ordinal); source.MoveTo(destination, item); Assert.Empty(source); var actual = destination.First().CanonicalForm; Assert.Equal(expected, actual); }
public void op_MoveTo_Lexicon_LexicalItemNull() { var obj = new LexicalCollection(NormalityComparer.Ordinal); var destination = new LexicalCollection(NormalityComparer.Ordinal); Assert.Throws<ArgumentNullException>(() => obj.MoveTo(destination, null)); }
public void op_Add_LexicalItemNull() { var obj = new LexicalCollection(NormalityComparer.Ordinal); // ReSharper disable RedundantCast Assert.Throws<ArgumentNullException>(() => obj.Add(null as LexicalItem)); // ReSharper restore RedundantCast }
public void op_MatchBeginning_string_whenContainsDoubleSpace() { const string expected = "Example"; var obj = new LexicalCollection(NormalityComparer.Ordinal) { expected }; Assert.Null(obj.MatchBeginning("a z")); }
public void op_Add_string_alreadyExistsAsSynonym() { const string expected = "foo"; var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add("bar").Synonyms.Add(expected); obj.Add(expected); Assert.Equal(1, obj.Count()); }
public void prop_CanonicalForms_get() { const string expected = "1"; var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add(expected).Synonyms.Add("One"); var actual = obj.CanonicalForms.First(); Assert.Equal(expected, actual); }
public void op_MatchWithin_string_whenShorterAndLonger() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "three"), new LexicalItem(NormalityComparer.Ordinal, "two three") }; var expected = new LexicalMatch(obj.Last()) { Prefix = "1", Suffix = "4" }; var actual = obj.MatchWithin("1 two three 4"); Assert.Equal(expected, actual); Assert.Equal("1", actual.Prefix); Assert.Equal("4", actual.Suffix); }
public void op_Remove_IEnumerableLexicalItemsSynonym() { var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add("Foo").Synonyms.Add("One"); var lexicon = new LexicalCollection(NormalityComparer.Ordinal); lexicon.Add("Bar").Synonyms.Add("One"); obj.Remove(lexicon); Assert.Equal(0, obj.Count()); }
public void op_MatchWithin_string() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "Example") }; var expected = new LexicalMatch(obj.First()) { Prefix = "This is an", Suffix = "test case" }; var actual = obj.MatchWithin("This is an example test case"); Assert.Equal(expected, actual); }
public void op_Contains_string_whenOrdinalIgnoreCaseComparer() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { "Example" }; Assert.True(obj.Contains("EXAMPLE")); }
public void op_MatchEnding_string_whenLongerAndShorter() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "two three"), new LexicalItem(NormalityComparer.Ordinal, "two") }; var expected = new LexicalMatch(obj.First()) { Prefix = "1" }; var actual = obj.MatchEnding("1 two three"); Assert.Equal(expected, actual); Assert.Equal("1", actual.Prefix); }
public void indexer_stringNull_get() { var obj = new LexicalCollection(NormalityComparer.Ordinal); Assert.Throws<ArgumentNullException>(() => obj[null]); }
public void op_MatchBeginning_string_whenShorterAndLonger() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "one"), new LexicalItem(NormalityComparer.Ordinal, "one two") }; var expected = new LexicalMatch(obj.Last()) { Suffix = "3" }; var actual = obj.MatchBeginning("one two 3"); Assert.Equal(expected, actual); Assert.Equal("3", actual.Suffix); }
public void op_Remove_IEnumerableLexicalItemsEmpty() { var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add("1").Synonyms.Add("One"); obj.Remove(new LexicalCollection(NormalityComparer.Ordinal)); Assert.Equal(1, obj.Count()); }
public void op_Match_string() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "Example") }; var expected = new LexicalMatch(obj.First()); var actual = obj.Match("EXAMPLE"); Assert.Equal(expected, actual); }
public void indexer_string_getWhenNotFound() { var obj = new LexicalCollection(NormalityComparer.Ordinal); Assert.Null(obj["Example"]); }
public void op_Contains_string() { var obj = new LexicalCollection(NormalityComparer.Ordinal) { "Example" }; Assert.True(obj.Contains("Example")); }
public void op_Remove_LexicalItem() { var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add("1").Synonyms.Add("One"); obj.Remove(new LexicalItem(NormalityComparer.Ordinal, "1")); Assert.Equal(0, obj.Count()); }
public void op_Add_string() { const string expected = "Example"; var obj = new LexicalCollection(NormalityComparer.Ordinal) { expected }; var actual = obj.First().CanonicalForm; Assert.Equal(expected, actual); }
public void op_ToCanonicalForm_string_whenOrdinalIgnoreCaseComparer() { const string expected = "1"; var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase); obj.Add(expected).Synonyms.Add("One"); var actual = obj.ToCanonicalForm("ONE"); Assert.Equal(expected, actual); }
public void op_MoveTo_LexiconNull_LexicalItem() { var obj = new LexicalCollection(NormalityComparer.Ordinal); var item = new LexicalItem(NormalityComparer.Ordinal, "Example"); Assert.Throws<ArgumentNullException>(() => obj.MoveTo(null, item)); }
public void op_Add_string_alreadyExists() { const string expected = "Example"; var obj = new LexicalCollection(NormalityComparer.Ordinal) { expected, expected }; Assert.Equal(1, obj.Count()); }
public void op_MoveTo_LexiconSame_LexicalItem() { var obj = new LexicalCollection(NormalityComparer.Ordinal); var item = new LexicalItem(NormalityComparer.Ordinal, "Example"); Assert.Throws<InvalidOperationException>(() => obj.MoveTo(obj, item)); }
public void op_Match_stringEmpty() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "Example") }; Assert.Null(obj.Match(string.Empty)); }
public void op_Invoke_Func() { var obj = new LexicalCollection(NormalityComparer.Ordinal); obj.Add(string.Concat("Foo", '\u00A0', "Bar")).Synonyms.Add(string.Concat("Left", '\u00A0', "Right")); obj.Invoke(x => x.NormalizeWhiteSpace()); Assert.Equal("Foo Bar", obj.First().CanonicalForm); Assert.Equal("Left Right", obj.First().Synonyms.First()); }
public void op_Match_stringNull() { var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase) { new LexicalItem(NormalityComparer.Ordinal, "Example") }; Assert.Throws<ArgumentNullException>(() => obj.Match(null)); }