ParserTestCase.java

/*
 * Copyright 2013 eXo Platform SAS
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package juzu.impl.router.regex;

import juzu.test.AbstractTestCase;
import org.junit.Test;

import java.util.regex.Pattern;

/**
 * @author <a href="mailto:julien.viet@exoplatform.com">Julien Viet</a>
 * @version $Revision$
 */
public class ParserTestCase extends AbstractTestCase {

  @Test
  public void testSomeStuff() {
    Pattern pattern = Pattern.compile("^[\\^a\b]$");
    assertTrue(pattern.matcher("^").matches());
    assertTrue(pattern.matcher("a").matches());

  }

  private static class ParserTester {
    private final REParser parser;

    private ParserTester(CharSequence s) {
      this.parser = new REParser(s);
    }

    ParserTester assertParseCharacterClass(String expectedValue) {
      try {
        RENode node = parser.parseExpression();
        assertTrue(node instanceof RENode.CharacterClass);
        assertEquals(expectedValue, node.toString());
        return this;
      }
      catch (SyntaxException e) {
        throw failure(e);
      }
    }

    ParserTester assertParseDisjunction(String expectedValue) {
      try {
        RENode.Disjunction disjunction = parser.parseDisjunction();
        assertTrue(parser.isDone());
        if (expectedValue.length() == 0) {
          assertNull(disjunction);
        }
        else {
          assertNotNull(disjunction);
          assertEquals(expectedValue, disjunction.toString());
        }
        return this;
      }
      catch (SyntaxException e) {
        throw failure(e);
      }
    }

    ParserTester assertNotParseDisjunction() {
      int expectedIndex = parser.getIndex();
      try {
        parser.parseDisjunction();
        fail();
      }
      catch (SyntaxException e) {
        assertEquals(expectedIndex, parser.getIndex());
      }
      return this;
    }

    ParserTester assertParseExpression(String expectedValue, int expectedIndex) {
      try {
        RENode.Expr exp = parser.parseExpression();
        assertEquals(expectedValue, exp.toString());
        assertEquals(expectedIndex, parser.getIndex());
        return this;
      }
      catch (SyntaxException e) {
        throw failure(e);
      }
    }

    ParserTester assertNotParseExpression() {
      try {
        RENode.Expr expr = parser.parseExpression();
        assertNull(expr);
      }
      catch (SyntaxException e) {
      }
      return this;
    }

    ParserTester assertParseQuantifier(Quantifier expectedQuantifier) {
      Quantifier quantifier;
      try {
        quantifier = parser.parseQuantifier();
      }
      catch (SyntaxException e) {
        throw failure(e);
      }
      if (expectedQuantifier != null) {
        assertEquals(expectedQuantifier, quantifier);
      }
      else {
        assertNull(quantifier);
      }
      return this;
    }
  }

  public void testDisjunction() {
    new ParserTester("a|").assertParseDisjunction("<c>a</c>|");
    new ParserTester("|a").assertParseDisjunction("|<c>a</c>");
    new ParserTester("a|b").assertParseDisjunction("<c>a</c>|<c>b</c>");
  }

  public void testExtendedRegexp() {
    new ParserTester("").assertParseDisjunction("");
    new ParserTester(".").assertParseDisjunction("<./>");
    new ParserTester("^").assertParseDisjunction("<^/>");
    new ParserTester("^$").assertParseDisjunction("<^/><$/>");
    new ParserTester("a").assertParseDisjunction("<c>a</c>");
    new ParserTester("a|b").assertParseDisjunction("<c>a</c>|<c>b</c>");
    new ParserTester("a|b|c").assertParseDisjunction("<c>a</c>|<c>b</c>|<c>c</c>");
    new ParserTester("a+|b*").assertParseDisjunction("<+><c>a</c></+>|<*><c>b</c></*>");
    new ParserTester("\\.").assertParseDisjunction("<c>.</c>");
  }

  public void testExpression() {
    new ParserTester("").assertNotParseExpression();
    new ParserTester("^").assertParseExpression("<^/>", 1);
    new ParserTester("^+").assertParseExpression("<+><^/></+>", 2);
    new ParserTester("$").assertParseExpression("<$/>", 1);
    new ParserTester("$+").assertParseExpression("<+><$/></+>", 2);
    new ParserTester("a").assertParseExpression("<c>a</c>", 1);
    new ParserTester("a+").assertParseExpression("<+><c>a</c></+>", 2);
    new ParserTester(".").assertParseExpression("<./>", 1);
    new ParserTester(".+").assertParseExpression("<+><./></+>", 2);
    new ParserTester("\\+").assertParseExpression("<c>+</c>", 2);
    new ParserTester("\\++").assertParseExpression("<+><c>+</c></+>", 3);
    new ParserTester("*").assertNotParseExpression();
    new ParserTester("+").assertNotParseExpression();
    new ParserTester("?").assertNotParseExpression();
    new ParserTester("{").assertNotParseExpression();
    new ParserTester("|").assertNotParseExpression();
  }

  public void testGroup() {
    new ParserTester("(a)").assertParseExpression("<(><c>a</c></(>", 3);
    new ParserTester("(a(b)c)").assertParseExpression("<(><c>a</c><(><c>b</c></(><c>c</c></(>", 7);
    new ParserTester("(?:a)").assertParseExpression("<(?:><c>a</c></(?:>", 5);
    new ParserTester("(?=a)").assertParseExpression("<(?=><c>a</c></(?=>", 5);
    new ParserTester("(?!a)").assertParseExpression("<(?!><c>a</c></(?!>", 5);
    new ParserTester("(?<=a)").assertParseExpression("<(?<=><c>a</c></(?<=>", 6);
    new ParserTester("(?<!a)").assertParseExpression("<(?<!><c>a</c></(?<!>", 6);
    new ParserTester("(?)").assertParseExpression("<(><c>?</c></(>", 3);
    new ParserTester("(?_)").assertNotParseExpression();
    new ParserTester("(?<_)").assertNotParseExpression();
  }

  // missing stuff:
  // escape in bracket


  public void testQuantifier() {
    new ParserTester("*").assertParseQuantifier(Quantifier.zeroOrMore(Quantifier.Mode.GREEDY));
    new ParserTester("+").assertParseQuantifier(Quantifier.oneOrMore(Quantifier.Mode.GREEDY));
    new ParserTester("?").assertParseQuantifier(Quantifier.onceOrNotAtAll(Quantifier.Mode.GREEDY));
    new ParserTester("*a").assertParseQuantifier(Quantifier.zeroOrMore(Quantifier.Mode.GREEDY));
    new ParserTester("+a").assertParseQuantifier(Quantifier.oneOrMore(Quantifier.Mode.GREEDY));
    new ParserTester("?a").assertParseQuantifier(Quantifier.onceOrNotAtAll(Quantifier.Mode.GREEDY));
    new ParserTester("*?").assertParseQuantifier(Quantifier.zeroOrMore(Quantifier.Mode.RELUCTANT));
    new ParserTester("+?").assertParseQuantifier(Quantifier.oneOrMore(Quantifier.Mode.RELUCTANT));
    new ParserTester("??").assertParseQuantifier(Quantifier.onceOrNotAtAll(Quantifier.Mode.RELUCTANT));
    new ParserTester("*+").assertParseQuantifier(Quantifier.zeroOrMore(Quantifier.Mode.POSSESSIVE));
    new ParserTester("++").assertParseQuantifier(Quantifier.oneOrMore(Quantifier.Mode.POSSESSIVE));
    new ParserTester("?+").assertParseQuantifier(Quantifier.onceOrNotAtAll(Quantifier.Mode.POSSESSIVE));
    new ParserTester("a").assertParseQuantifier(null);
    new ParserTester("").assertParseQuantifier(null);
    new ParserTester("{2}").assertParseQuantifier(Quantifier.exactly(Quantifier.Mode.GREEDY, 2));
    new ParserTester("{2,}").assertParseQuantifier(Quantifier.atLeast(Quantifier.Mode.GREEDY, 2));
    new ParserTester("{2,4}").assertParseQuantifier(Quantifier.between(Quantifier.Mode.GREEDY, 2, 4));
  }

  public void testParseBracketExpression() {
    new ParserTester("[a]").assertParseCharacterClass("[a]");
    new ParserTester("[^a]").assertParseCharacterClass("[^[a]]");
    new ParserTester("[^a-b]").assertParseCharacterClass("[^[a-b]]");
    new ParserTester("[a-b]").assertParseCharacterClass("[a-b]");
    new ParserTester("[ab]").assertParseCharacterClass("[[a]||[b]]");
    new ParserTester("[a&]").assertParseCharacterClass("[[a]||[&]]");
    new ParserTester("[a&&b]").assertParseCharacterClass("[[a]&&[b]]");
    new ParserTester("[a&&[^b]]").assertParseCharacterClass("[[a]&&[^[b]]]");
    new ParserTester("[a[^b]]").assertParseCharacterClass("[[a]||[^[b]]]");
    new ParserTester("[a[b]]").assertParseCharacterClass("[[a]||[b]]");
    new ParserTester("[a[b]c]").assertParseCharacterClass("[[a]||[[b]||[c]]]");
    new ParserTester("[[a]bc]").assertParseCharacterClass("[[a]||[[b]||[c]]]");
    new ParserTester("[-]").assertParseCharacterClass("[-]");
    new ParserTester("[a-]").assertParseCharacterClass("[[a]||[-]]");
//      new ParserTester("[---]").assertParseCharacterClass("[---]");
    new ParserTester("[#--]").assertParseCharacterClass("[#--]");
  }

}