public void TestAtLeastRendering()
        {
            RegexQuantifier quantifier1 = RegexQuantifier.AtLeast(5);

            Assert.AreEqual("{5,}", quantifier1.ToRegexPattern());
            quantifier1.IsLazy = true;
            Assert.AreEqual("{5,}?", quantifier1.ToRegexPattern());

            RegexQuantifier quantifier2 = RegexQuantifier.Custom(5, null, false);

            Assert.AreEqual("{5,}", quantifier2.ToRegexPattern());
            quantifier2.IsLazy = true;
            Assert.AreEqual("{5,}?", quantifier2.ToRegexPattern());
        }
        public void TestOneOrMoreRendering()
        {
            RegexQuantifier quantifier1 = RegexQuantifier.OneOrMore;

            Assert.AreEqual("+", quantifier1.ToRegexPattern());
            quantifier1.IsLazy = true;
            Assert.AreEqual("+?", quantifier1.ToRegexPattern());

            RegexQuantifier quantifier2 = RegexQuantifier.AtLeast(1);

            Assert.AreEqual("+", quantifier2.ToRegexPattern());
            quantifier2.IsLazy = true;
            Assert.AreEqual("+?", quantifier2.ToRegexPattern());

            RegexQuantifier quantifier3 = RegexQuantifier.Custom(1, null, false);

            Assert.AreEqual("+", quantifier3.ToRegexPattern());
            quantifier3.IsLazy = true;
            Assert.AreEqual("+?", quantifier3.ToRegexPattern());
        }
        public void TestZeroOrMoreRendering()
        {
            RegexQuantifier quantifier1 = RegexQuantifier.ZeroOrMore;

            Assert.AreEqual("*", quantifier1.ToRegexPattern());
            quantifier1.IsLazy = true;
            Assert.AreEqual("*?", quantifier1.ToRegexPattern());

            RegexQuantifier quantifier2 = RegexQuantifier.AtLeast(0);

            Assert.AreEqual("*", quantifier2.ToRegexPattern());
            quantifier2.IsLazy = true;
            Assert.AreEqual("*?", quantifier2.ToRegexPattern());

            RegexQuantifier quantifier3 = RegexQuantifier.Custom(0, null, false);

            Assert.AreEqual("*", quantifier3.ToRegexPattern());
            quantifier3.IsLazy = true;
            Assert.AreEqual("*?", quantifier3.ToRegexPattern());
        }
예제 #4
0
        public void TestAtLeastMethodShouldReturnProperObject()
        {
            RegexQuantifier greedyQuantifier = RegexQuantifier.AtLeast(5);

            Assert.AreEqual(5, greedyQuantifier.MinOccurrenceCount);
            Assert.AreEqual(null, greedyQuantifier.MaxOccurrenceCount);
            Assert.IsFalse(greedyQuantifier.IsLazy);

            RegexQuantifier lazyQuantifier1 = RegexQuantifier.AtLeast(5, false);

            Assert.AreEqual(5, lazyQuantifier1.MinOccurrenceCount);
            Assert.AreEqual(null, lazyQuantifier1.MaxOccurrenceCount);
            Assert.IsFalse(lazyQuantifier1.IsLazy);

            RegexQuantifier lazyQuantifier2 = RegexQuantifier.AtLeast(5, true);

            Assert.AreEqual(5, lazyQuantifier2.MinOccurrenceCount);
            Assert.AreEqual(null, lazyQuantifier2.MaxOccurrenceCount);
            Assert.IsTrue(lazyQuantifier2.IsLazy);

            Assert.AreNotSame(greedyQuantifier, lazyQuantifier1);
            Assert.AreNotSame(greedyQuantifier, lazyQuantifier2);
            Assert.AreNotSame(lazyQuantifier1, lazyQuantifier2);
        }
        public void TestAlternationNodeRendering()
        {
            RegexNodeLiteral literal1 = new RegexNodeLiteral(@"\w*");
            RegexNodeLiteral literal2 = new RegexNodeLiteral(@"\d+");
            RegexNodeLiteral literal3 = new RegexNodeLiteral(@"\s?");

            RegexNodeAlternation alternation1 = new RegexNodeAlternation(literal1, literal2);

            Assert.AreEqual(@"(?:\w*|\d+)", alternation1.ToRegexPattern());

            RegexNodeAlternation alternation2 = new RegexNodeAlternation(literal1, literal2, literal3);

            Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation2.ToRegexPattern());

            RegexNodeAlternation alternation3 = RegexBuilder.Alternate(literal1, literal2);

            Assert.AreEqual(@"(?:\w*|\d+)", alternation3.ToRegexPattern());

            RegexNodeAlternation alternation4 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 });

            Assert.AreEqual(@"(?:\w*|\d+|\s?)", alternation4.ToRegexPattern());

            RegexNodeAlternation alternation5 = new RegexNodeAlternation(literal1, literal2);

            alternation5.Quantifier = RegexQuantifier.ZeroOrMore;
            Assert.AreEqual(@"(?:\w*|\d+)*", alternation5.ToRegexPattern());

            RegexNodeAlternation alternation6 = new RegexNodeAlternation(literal1, literal2, literal3);

            alternation6.Quantifier = RegexQuantifier.OneOrMore;
            Assert.AreEqual(@"(?:\w*|\d+|\s?)+", alternation6.ToRegexPattern());

            RegexNodeAlternation alternation7 = RegexBuilder.Alternate(literal1, literal2, RegexQuantifier.ZeroOrOne);

            Assert.AreEqual(@"(?:\w*|\d+)?", alternation7.ToRegexPattern());

            RegexNodeAlternation alternation8 = RegexBuilder.Alternate(new RegexNode[] { literal1, literal2, literal3 }, RegexQuantifier.AtLeast(5));

            Assert.AreEqual(@"(?:\w*|\d+|\s?){5,}", alternation8.ToRegexPattern());
        }