Add a test that patterns are not both negated and optional. The logic is hard to define (perhaps someone will eventually come up with a use case)

Author: AngledLuffa

src/edu/stanford/nlp/trees/tregex/CoordinationPattern.java

@@ -36,6 +36,11 @@ public String localString() {
   @Override
   public String toString() {
     StringBuilder sb = new StringBuilder();
+
+    if (isNegated() && isOptional()) {
+      throw new AssertionError("Shenanigans!  The parser should not allow a pattern which is both negated and optional");
+    }
+
     if (isConj) {
       if (isNegated()) {
         sb.append("!(");

src/edu/stanford/nlp/trees/tregex/TregexPattern.java

@@ -365,14 +365,14 @@ public abstract class TregexPattern implements Serializable  {
   void negate() {
     neg = true;
     if (opt) {
-      throw new RuntimeException("Node cannot be both negated and optional.");
+      throw new IllegalStateException("Node cannot be both negated and optional.");
     }
   }
 
   void makeOptional() {
     opt = true;
     if (neg) {
-      throw new RuntimeException("Node cannot be both negated and optional.");
+      throw new IllegalStateException("Node cannot be both negated and optional.");
     }
   }
 

src/edu/stanford/nlp/trees/tregex/TregexPatternCompiler.java

@@ -142,6 +142,8 @@ public TregexPattern compile(String tregex) {
       throw new TregexParseException("Could not parse " + tregex, tme);
     } catch (ParseException e) {
       throw new TregexParseException("Could not parse " + tregex, e);
+    } catch (IllegalStateException e) {
+      throw new TregexParseException("Could not parse " + tregex, e);
     }
     pattern.setPatternString(tregex);
     return pattern;

test/src/edu/stanford/nlp/trees/tregex/TregexTest.java

@@ -1523,6 +1523,42 @@ public void testOptional() {
     assertFalse(matcher.find());
   }
 
+  /** The parser should not allow a pattern which is both negated and optional */
+  public void testNegatedOptional() {
+    TregexPattern pattern;
+    // these should be fine
+    pattern = TregexPattern.compile("A ?< B");
+    pattern = TregexPattern.compile("A !< B");
+    // this should break
+    try {
+      pattern = TregexPattern.compile("A !?< B");
+    } catch (TregexParseException e) {
+      // yay, passed
+    }
+    // this should also break
+    try {
+      pattern = TregexPattern.compile("A ?!< B");
+    } catch (TregexParseException e) {
+      // yay, passed
+    }
+
+    // these should be fine
+    pattern = TregexPattern.compile("A ?(< B < C)");
+    pattern = TregexPattern.compile("A !(< B < C)");
+    // this should break
+    try {
+      pattern = TregexPattern.compile("A !?(< B < C)");
+    } catch (TregexParseException e) {
+      // yay, passed
+    }
+    // this should also break
+    try {
+      pattern = TregexPattern.compile("A ?!(< B < C)");
+    } catch (TregexParseException e) {
+      // yay, passed
+    }
+  }
+
   /**
    * A user supplied an example of a negated disjunction which went into an infinite loop.
    * Apparently no one had ever used a negated disjunction of tree structures before!