Exemplo n.º 1
0
        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());
        }
Exemplo n.º 2
0
        public void op_ToCanonicalForm_string()
        {
            const string expected = "1";

            var obj = new LexicalCollection(NormalityComparer.Ordinal);

            obj.Add(expected).Synonyms.Add("One");

            var actual = obj.ToCanonicalForm(obj.First().Synonyms.First());

            Assert.Equal(expected, actual);
        }
Exemplo n.º 3
0
        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);
        }
Exemplo n.º 4
0
        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);
        }
Exemplo n.º 5
0
        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);
        }
Exemplo n.º 6
0
        public void op_MatchEnding_string()
        {
            var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase)
            {
                new LexicalItem(NormalityComparer.Ordinal, "Example")
            };

            var expected = new LexicalMatch(obj.First())
            {
                Prefix = "This is an"
            };
            var actual = obj.MatchEnding("This is an example");

            Assert.Equal(expected, actual);
        }
Exemplo n.º 7
0
        public void op_MatchBeginning_string()
        {
            var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase)
            {
                new LexicalItem(NormalityComparer.Ordinal, "Example")
            };

            var expected = new LexicalMatch(obj.First())
            {
                Suffix = "test case"
            };
            var actual = obj.MatchBeginning("example test case");

            Assert.Equal(expected, actual);
        }
Exemplo n.º 8
0
        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);
        }
Exemplo n.º 9
0
        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);
        }
Exemplo n.º 10
0
        public void op_MatchBeginning_string_whenLongerAndShorter()
        {
            var obj = new LexicalCollection(NormalityComparer.OrdinalIgnoreCase)
            {
                new LexicalItem(NormalityComparer.Ordinal, "one two"),
                new LexicalItem(NormalityComparer.Ordinal, "one")
            };

            var expected = new LexicalMatch(obj.First())
            {
                Suffix = "3"
            };
            var actual = obj.MatchBeginning("one two 3");

            Assert.Equal(expected, actual);
            Assert.Equal("3", actual.Suffix);
        }