public void ConstructorSucceeds()
 {
     int min = 0;
      int max = int.MaxValue;
      var expression = new RepeatExpression<char> (m_A);
      Assert.AreEqual (min, expression.Minimum, "Minimum");
      Assert.AreEqual (max, expression.Maximum, "Maximum");
 }
 public void NotSupportsLookBack_For_LookBackNotSupported()
 {
     var expression = new RepeatExpression<char> (LookBackNotSupported);
      Assert.IsFalse (expression.SupportsLookBack);
 }
 public void ExactConstructorThrowArgumentOutOfRangeException()
 {
     var expression = new RepeatExpression<char> (m_any, -1);
 }
        public void GetMatchesFindsOneMatchesForEmpty()
        {
            RepeatExpression<char> expression = new RepeatExpression<char> (m_any);

             var matches = expression.GetMatches (EmptyList, 0).ToList ();

             Assert.AreEqual (1, matches.Count (), "Count");
             Assert.AreEqual (0, matches[0].Index, "Count");
             Assert.AreEqual (0, matches[0].Length, "Count");
        }
Ejemplo n.º 5
0
        public LilypondSequenceReader(string lilyContent)
        {
            string[] lilypondText = lilyContent.Split().Where(item => item.Length > 0).ToArray();

            LilypondContext         context     = new LilypondContext();
            Stack <LilypondSection> sections    = new Stack <LilypondSection>();
            LilypondSection         rootSection = null;

            for (int i = 0; i < lilypondText.Length; i++)
            {
                switch (lilypondText[i])
                {
                case "\\relative":
                    // New relative section start with a startPitch and an ocatveChange
                    RelativeExpression relativeExpression = new RelativeExpression(lilypondText[i + 1][0],
                                                                                   string.Concat(lilypondText[i + 1].Skip(1)));

                    sections.Push(relativeExpression);

                    if (rootSection == null)
                    {
                        rootSection = relativeExpression;
                    }

                    i += 2;
                    break;

                case "\\repeat":
                    RepeatExpression repeatExpression = new RepeatExpression();

                    sections.Peek()?.ChildExpressions.Add(repeatExpression);
                    sections.Push(repeatExpression);

                    i += 3;
                    break;

                case "\\alternative":
                    AlternativeExpression alternativeExpression = new AlternativeExpression();

                    sections.Peek()?.ChildExpressions.Add(alternativeExpression);
                    sections.Push(alternativeExpression);

                    context.InAlternative = true;
                    i++;
                    break;

                case "\\clef":
                    sections.Peek().ChildExpressions.Add(new ClefExpression(lilypondText[i + 1]));
                    i++;
                    break;

                case "\\tempo":
                    sections.Peek().ChildExpressions.Add(new TempoExpression(lilypondText[i + 1]));
                    i += 1;
                    break;

                case "\\time":
                    sections.Peek().ChildExpressions.Add(new TimeSignatureExpression(lilypondText[i + 1]));
                    i++;
                    break;

                case "{":
                    if (context.InAlternative)
                    {
                        // There is a new alternative group in the current alternative block
                        AlternativeGroupExpression alternativeGroup = new AlternativeGroupExpression();

                        sections.Peek()?.ChildExpressions.Add(alternativeGroup);
                        sections.Push(alternativeGroup);

                        context.InAlternativeGroup = true;
                    }
                    else
                    {
                        LilypondSection lilypondSection = new LilypondSection();

                        if (sections.Any())
                        {
                            sections.Peek()?.ChildExpressions.Add(lilypondSection);
                            sections.Push(lilypondSection);
                        }
                    }
                    break;

                case "}":     // Section has ended. It is no longer the current section, so pop it from the stack
                    if (context.InRepeat)
                    {
                        if (lilypondText[i + 1] != "\\alternative")
                        {
                            sections.Peek().ChildExpressions.Add(new BarlineExpression(true));
                        }

                        context.InRepeat = false;
                    }
                    if (sections.Any())
                    {
                        sections.Pop();
                    }
                    break;

                case "|": sections.Peek().ChildExpressions.Add(new BarlineExpression()); break;

                // It is a note or an unknown token
                default:
                    try
                    {
                        sections.Peek().ChildExpressions.Add(new NoteExpression(lilypondText[i]));
                        break;
                    }
                    catch (Exception)
                    {
                        /* It is an unknown token, skip it. */ break;
                    }
                }
            }

            rootSection.Interpret(context);

            if (!context.ClefAdded)
            {
                context.Sequence.Symbols.Insert(0, new Clef(ClefType.GClef));
            }

            Sequence = context.Sequence;
        }
 public void ConstructorThrowArgumentNullExceptionForNullArray()
 {
     var expression = new RepeatExpression<char> ((IExpression<char>) null);
 }
 public void AnyLength_For_AnyLength_NotAnyLength()
 {
     var expression = new RepeatExpression<char> (
     new ListExpression<char> (AnyLength, NotAnyLength));
      Assert.IsTrue (expression.AnyLength);
 }
 public void RangeConstructorArgumentOutOfRangeExceptionForNegativeMinimum()
 {
     var expression = new RepeatExpression<char> (m_any, -1, 23);
 }
        public void GetMatchesOf_A_ForAAABBB_LikeRegex()
        {
            var expression = new RepeatExpression<char> (m_A);

             expression.AssertMatches ("AAABBB", "A*?");
        }
        public void GetMatchesOf_A_3_ForAAABBBReturnsAAA()
        {
            int index = 0;
             int length = 3;
             RepeatExpression<char> expression = new RepeatExpression<char> (m_A, length);

             var list = AAABBB;
             var matches = expression.GetMatches (list, index).ToList ();

             Assert.AreEqual (1, matches.Count (), "Count");
             foreach (var match in matches)
             {
            Assert.AreEqual (index, match.Index, "match.Index");
            Assert.AreEqual (length, match.Length, "match.Length");
            Assert.IsTrue (match.Success, "match.Success");
            Assert.AreEqual (length, match.Items.Count, "match.Items.Count");
            for (int i = 0; i < length; i++)
            {
               Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
            }
             }
        }
        public void GetMatchesOf_Any_2_ForDigetsStartingAt5Returns56()
        {
            int index = 5;
             RepeatExpression<char> expression = new RepeatExpression<char> (m_any, 2);
             int length = 2;

             var list = DigetsList;
             var matches = expression.GetMatches (list, index).ToList ();

             Assert.AreEqual (1, matches.Count (), "Count");
             foreach (var match in matches)
             {
            Assert.AreEqual (index, match.Index, "match.Index");
            Assert.AreEqual (length, match.Length, "match.Length");
            Assert.IsTrue (match.Success, "match.Success");
            Assert.AreEqual (length, match.Items.Count, "match.Items.Count");
            for (int i = 0; i < length; i++)
            {
               Assert.AreEqual (list[index + i], match.Items [i], "match.Items [" + i + "]");
            }
             }
        }
        public void GetMatchesOf_AAorAB_0_4_ForAAABBB()
        {
            int index = 0;
             RepeatExpression<char> expression =
            new RepeatExpression<char> (
               new AlternationExpression<char> (
                  new ListExpression<char>(m_A, m_A),
                  new ListExpression<char>(m_A, m_B, m_B, m_B)),
               0, 4);

             var list = AAABBB;
             var matches = expression.GetMatches (list, index).ToList ();

             string [] expectedValues = new [] {"", "AA", "AAABBB"};
             Assert.AreEqual (expectedValues.Length, matches.Count (), "Count");
             for (int i = 0; i < expectedValues.Length; i++)
             {
            var match = matches [i];
            string expected = expectedValues [i];
            Assert.AreEqual (index, match.Index, "match.Index at " + i);
            Assert.AreEqual (expected.Length, match.Length, "match.Length at " + i);
            Assert.IsTrue (match.Success, "match.Success at " + i);
            Assert.AreEqual (expected.Length, match.Items.Count, "match.Items.Count at " + i);

            Assert.AreEqual (expected, new string (match.Items.ToArray ()), "Value at " + i);
             }
        }
        public void GetMatchesOfDigits_Any_4_8()
        {
            var expression = new RepeatExpression<char> (m_any, 4, 8);

             string [] expectedValues = new [] {"0123", "01234", "012345", "0123456", "01234567"};

             int index = 0;
             var list = DigetsList;

             var matches = expression.GetMatches (list, index).ToList ();

             Assert.AreEqual (expectedValues.Length, matches.Count (), "Count");
             for (int i = 0; i < expectedValues.Length; i++)
             {
            var match = matches [i];
            var expected = expectedValues [i];
            Assert.AreEqual (index, match.Index, "match.Index at " + i);
            Assert.AreEqual (expected.Length, match.Length, "match.Length at " + i);
            Assert.IsTrue (match.Success, "match.Success at " + i);
            Assert.AreEqual (expected.Length, match.Items.Count, "match.Items.Count at " + i);
            Assert.AreEqual (expected, new string (match.Items.ToArray ()), "Value at " + i);
             }
        }
        public void GetMatchesFindsOneMatchForA()
        {
            RepeatExpression<char> expression = new RepeatExpression<char> (m_A);

             int index = 0;
             var list = AList;
             var matches = expression.GetMatches (list, index).ToList ();

             Assert.AreEqual (2, matches.Count (), "Count");
             Assert.AreEqual (0, matches.First ().Length, "First match should be empty");
             var match = matches.ElementAt(1);
             Assert.AreEqual (index, match.Index, "match.Index");
             Assert.AreEqual (1, match.Length, "match.Length");
             Assert.IsTrue (match.Success, "match.Success");
             Assert.AreEqual (1, match.Items.Count, "match.Items.Count");
             Assert.AreEqual (list[index], match.Items [0], "match.Items [0]");
        }
 public void NotSupportsLookBack_For_LookBackSupported_LookBackNotSupported()
 {
     var expression = new RepeatExpression<char> (new AlternationExpression<char> (LookBackSupported, LookBackNotSupported), 2);
      Assert.IsFalse (expression.SupportsLookBack);
 }
 public void RangeConstructorArgumentExceptionForMaximumLessThanMinimum()
 {
     var expression = new RepeatExpression<char> (m_any, 4, 3);
 }
 public void GetPossibleMatchLengths_For1_1()
 {
     var expected = new int [] {2};
      var expression = new RepeatExpression<char> (MatchLength1,2);
      expression.AssertPossibleMatchLengths (expected);
 }
 public void SupportsLookBack_For_LookBackSupported()
 {
     var expression = new RepeatExpression<char> (LookBackSupported, 2,4);
      Assert.IsTrue (expression.SupportsLookBack);
 }
 public void GetPossibleMatchLengths_For1_4to6()
 {
     var expected = new int [] {4,5,6};
      var expression = new RepeatExpression<char> (MatchLength1, 4, 6);
      expression.AssertPossibleMatchLengths (expected);
 }
 public void GetPossibleMatchLengths_ForEmpty()
 {
     var expected = new int [] {0};
      var expression = new RepeatExpression<char> (new AlternationExpression<char>());
      expression.AssertPossibleMatchLengths (expected);
 }
 public void GetPossibleMatchLengths_For_2_3to4()
 {
     var expected = new int [] {6,8};
      var expression = new RepeatExpression<char> (MatchLength2, 3,4);
      expression.AssertPossibleMatchLengths (expected);
 }
 public void ExactConstructorSucceeds()
 {
     int min = 2;
      int max = min;
      var expression = new RepeatExpression<char> (m_A, min);
      Assert.AreEqual (min, expression.Minimum, "Minimum");
      Assert.AreEqual (max, expression.Maximum, "Maximum");
 }
 public void GetPossibleMatchLengths_For_3to5_2to3()
 {
     var expected = new int [] {3+3,3+3+3,3+3+4,3+3+5,3+4,3+4+5,3+5,3+5+5,4+5+5,5+5+5};
      var expression = new RepeatExpression<char> (MatchLengths3to5, 2,3);
      expression.AssertPossibleMatchLengths (expected);
 }
Ejemplo n.º 24
0
            public SingleExpression(TextReader reader)
            {
                while (reader.Peek() != -1)
                {
                    char c = (char)reader.Peek();

                    if (c == '(')
                    {
                        reader.Read();
                        Expression = new SingleExpression(reader);
                        if ((char)reader.Read() != ')')
                        {
                            throw new Exception("Expected )");
                        }
                    }
                    else if (c == ')')
                    {
                        return;
                    }
                    else if (c == '[')
                    {
                        reader.Read();
                        Expression = new RangeExpression(reader);
                        if ((char)reader.Read() != ']')
                        {
                            throw new Exception("Expected ]");
                        }
                    }
                    else if (c == '{')
                    {
                        reader.Read();
                        Expression = new RepeatExpression(reader)
                        {
                            Expression = Expression
                        };
                        if ((char)reader.Read() != '}')
                        {
                            throw new Exception("Expected }");
                        }
                    }
                    else if (c == '|')
                    {
                        reader.Read();
                        Expression = new OrExpression {
                            Left = Expression, Right = new SingleExpression(reader)
                        };
                    }
                    else if (c == '.')
                    {
                        reader.Read();
                        Expression = new ConcatExpression {
                            Left = Expression, Right = new SingleExpression(reader).Expression
                        };
                    }
                    else if (c == '*')
                    {
                        reader.Read();
                        Expression = new StarExpression {
                            Expression = Expression
                        };
                    }
                    else if (c == '+')
                    {
                        reader.Read();
                        Expression = new PlusExpression {
                            Expression = Expression
                        };
                    }
                    else
                    {
                        throw new Exception("Unexpected " + c);
                    }
                }
            }
 public void NotAnyLength_For_NotAnyLength()
 {
     var expression = new RepeatExpression<char> (NotAnyLength, 2);
      Assert.IsFalse (expression.AnyLength);
 }
        public void GetMatchesOfAnyQuestionStar_LikeRegex()
        {
            RepeatExpression<char> expression = new RepeatExpression<char> (m_any);

             expression.AssertMatches ("", ".*?");
        }
Ejemplo n.º 27
0
            public SingleExpression(TextReader reader)
            {
                while (reader.Peek() != -1)
                {
                    char c = (char)reader.Peek();

                    if (c == '(')
                    {
                        reader.Read();
                        Expression = new SingleExpression(reader);
                        if ((char)reader.Read() != ')')
                            throw new Exception("Expected )");
                    }
                    else if (c == ')')
                    {
                        return;
                    }
                    else if (c == '[')
                    {
                        reader.Read();
                        Expression = new RangeExpression(reader);
                        if ((char)reader.Read() != ']')
                            throw new Exception("Expected ]");
                    }
                    else if (c == '{')
                    {
                        reader.Read();
                        Expression = new RepeatExpression(reader) { Expression = Expression };
                        if ((char)reader.Read() != '}')
                            throw new Exception("Expected }");
                    }
                    else if (c == '|')
                    {
                        reader.Read();
                        Expression = new OrExpression { Left = Expression, Right = new SingleExpression(reader) };
                    }
                    else if (c == '.')
                    {
                        reader.Read();
                        Expression = new ConcatExpression { Left = Expression, Right = new SingleExpression(reader).Expression };
                    }
                    else if (c == '*')
                    {
                        reader.Read();
                        Expression = new StarExpression { Expression = Expression };
                    }
                    else if (c == '+')
                    {
                        reader.Read();
                        Expression = new PlusExpression { Expression = Expression };
                    }
                    else
                    {
                        throw new Exception("Unexpected " + c);
                    }
                }
            }