Esempio n. 1
0
        public void ShouldCreateAnyCharacterPredicate()
        {
            IAnyCharacter predicate;

            predicate = Parse.AnyCharacter();
            Assert.IsNotNull(predicate);
        }
        public void ShouldCreateSequencePredicateAddingZeroOrMoreTimes()
        {
            ISequence predicate;

            predicate = Parse.Character('a').ThenZeroOrMoreTimes('b').ThenCharacter('c');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(ZeroOrMoreTimes));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(Character));

            predicate = Parse.Character('a').ThenCharacter('c').ThenZeroOrMoreTimes('b');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(ZeroOrMoreTimes));

            predicate = Parse.Character('a').ThenZeroOrMoreTimes(Parse.AnyCharacter()).ThenCharacter('c');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(ZeroOrMoreTimes));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(Character));
        }
        public void ShouldCreateOrPredicateAddingPerhaps()
        {
            IOr predicate;

            predicate = Parse.Character('a').OrPerhaps('b').OrCharacter('c');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(Perhaps));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(Character));

            predicate = Parse.Character('a').OrCharacter('c').OrPerhaps('b');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(Perhaps));

            predicate = Parse.Character('a').OrPerhaps(Parse.AnyCharacter()).OrCharacter('c');
            Assert.IsNotNull(predicate);
            Assert.AreEqual(3, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(Perhaps));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(2), typeof(Character));
        }
Esempio n. 4
0
        public void ShouldConvertToString()
        {
            IPredicate predicate;

            predicate = Parse.AnyCharacter();
            Assert.AreEqual(".", predicate.ToString());
        }
Esempio n. 5
0
        public void ShouldAccept()
        {
            AnyCharacter predicate;

            predicate = Parse.AnyCharacter();
            Assert.IsTrue(predicate.Accept('a'));
            Assert.IsTrue(predicate.Accept('b'));
            Assert.IsTrue(predicate.Accept('c'));
        }
        public void ShouldCreateOrPredicateAddingAbstractPredicate()
        {
            IOr predicate;

            predicate = Parse.Character('a').Or(Parse.AnyCharacter());
            Assert.IsNotNull(predicate);
            Assert.AreEqual(2, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(AnyCharacter));

            predicate = Parse.Character('a').Or('b'.OneOrMoreTimes());
            Assert.IsNotNull(predicate);
            Assert.AreEqual(2, predicate.Items.Count());
            Assert.IsInstanceOfType(predicate.Items.ElementAt(0), typeof(Character));
            Assert.IsInstanceOfType(predicate.Items.ElementAt(1), typeof(OneOrMoreTimes));
        }
Esempio n. 7
0
        public void ShouldBuildSituationSegmentUsingSequence()
        {
            IPredicate               predicate;
            SituationSegment         nextSegment;
            ISituationSegmentFactory factory;
            ISituationSegment        segment;

            predicate = Parse.AnyCharacter().ThenCharacter('a').ThenCharacter('b');

            nextSegment = new SituationSegment();
            nextSegment.InputTransitions.Add(new ReductionTransition());

            factory = new SituationSegmentFactory();
            segment = factory.BuildSituationSegment(predicate, nextSegment);

            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(Character), typeof(Character)));
        }
Esempio n. 8
0
        public void ShouldBuildSituationSegmentUsingComplexPredicate()
        {
            IPredicate               predicate;
            SituationSegment         nextSegment;
            ISituationSegmentFactory factory;
            ISituationSegment        segment;

            #region or inside a sequence
            predicate = Parse.AnyCharacter().Then(Parse.Character('a').OrCharacter('b')).ThenAnyCharacter();

            nextSegment = new SituationSegment();
            nextSegment.InputTransitions.Add(new ReductionTransition());

            factory = new SituationSegmentFactory();
            segment = factory.BuildSituationSegment(predicate, nextSegment);

            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(Character), typeof(AnyCharacter)));
            #endregion

            #region optional sequence in sequence
            predicate = Parse.AnyCharacter().Then(Parse.Character('a').ThenCharacter('b').Perhaps()).ThenAnyCharacter();

            nextSegment = new SituationSegment();
            nextSegment.InputTransitions.Add(new ReductionTransition());

            factory = new SituationSegmentFactory();
            segment = factory.BuildSituationSegment(predicate, nextSegment);

            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(Character), typeof(Character), typeof(AnyCharacter)));
            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(AnyCharacter)));
            #endregion

            #region one or more inside a sequence
            predicate = Parse.AnyCharacter().Then(Parse.Character('b').OneOrMoreTimes()).ThenAnyCharacter();

            nextSegment = new SituationSegment();
            nextSegment.InputTransitions.Add(new ReductionTransition());

            factory = new SituationSegmentFactory();
            segment = factory.BuildSituationSegment(predicate, nextSegment);

            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(Character), typeof(AnyCharacter)));
            Assert.IsTrue(ParseSegment(segment, typeof(AnyCharacter), typeof(Character), typeof(Character), typeof(Character), typeof(AnyCharacter)));
            #endregion
        }
Esempio n. 9
0
        public void ShouldCreateOneOrMoreTimesPredicate()
        {
            IOneOrMoreTimes predicate;

            predicate = Parse.OneOrMoreTimes('a');
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Character));

            predicate = Parse.OneOrMoreTimes(Parse.AnyCharacter());
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(AnyCharacter));

            predicate = Parse.OneOrMoreTimes(Parse.Character('a').ThenAnyCharacter());
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Sequence));
        }
Esempio n. 10
0
        public void ShouldCreatePerhapsPredicate()
        {
            IPerhaps predicate;

            predicate = 'a'.Perhaps();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Character));

            predicate = Parse.Character('a').Perhaps();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Character));

            predicate = Parse.AnyCharacter().Perhaps();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(AnyCharacter));

            predicate = Parse.Character('a').ThenCharacter('b').Perhaps();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Sequence));
        }
Esempio n. 11
0
        public void ShouldCreateZeroOrMoreTimesPredicate()
        {
            IZeroOrMoreTimes predicate;

            predicate = 'a'.ZeroOrMoreTimes();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Character));

            predicate = Parse.Character('a').ZeroOrMoreTimes();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Character));

            predicate = Parse.AnyCharacter().ZeroOrMoreTimes();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(AnyCharacter));

            predicate = Parse.Character('a').ThenCharacter('b').ZeroOrMoreTimes();
            Assert.IsNotNull(predicate);
            Assert.IsNotNull(predicate.Item);
            Assert.IsInstanceOfType(predicate.Item, typeof(Sequence));
        }