platform/structuralsearch/testSource/com/intellij/structuralsearch/impl/matcher/compiler/StringToConstraintsTransformerTest.java

   1 /*
   2  * Copyright 2000-2016 JetBrains s.r.o.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16 package com.intellij.structuralsearch.impl.matcher.compiler;
  17
  18 import com.intellij.structuralsearch.MalformedPatternException;
  19 import com.intellij.structuralsearch.MatchOptions;
  20 import com.intellij.structuralsearch.MatchVariableConstraint;
  21 import com.intellij.structuralsearch.UnsupportedPatternException;
  22 import com.intellij.structuralsearch.plugin.ui.Configuration;
  23 import org.junit.Before;
  24 import org.junit.Test;
  25
  26 import static org.junit.Assert.assertEquals;
  27 import static org.junit.Assert.assertTrue;
  28 import static org.junit.Assert.assertFalse;
  29
  30 /**
  31  * @author Bas Leijdekkers
  32  */
  33 public class StringToConstraintsTransformerTest {
  34
  35   private MatchOptions myOptions;
  36
  37   @Before
  38   public void setUp() throws Exception {
  39     myOptions = new MatchOptions();
  40   }
  41
  42   @Test(expected = MalformedPatternException.class)
  43   public void testCharacterExpectedAfterQuote() {
  44     test("' asdf");
  45   }
  46
  47   @Test(expected = MalformedPatternException.class)
  48   public void testCharacterExpectedAfterQuote2() {
  49     test("'");
  50   }
  51
  52   @Test(expected = MalformedPatternException.class)
  53   public void testUnexpectedEndOfPattern() {
  54     test("'_a{");
  55   }
  56
  57   @Test(expected = MalformedPatternException.class)
  58   public void testDigitExpected() {
  59     test("'a{a");
  60   }
  61
  62   @Test(expected = MalformedPatternException.class)
  63   public void testDigitExpected2() {
  64     test("'a{1,a}");
  65   }
  66
  67   @Test
  68   public void testZeroOccurs() {
  69     test("'a{,}");
  70     final MatchVariableConstraint constraint = myOptions.getVariableConstraint("a");
  71     assertEquals(0, constraint.getMinCount());
  72     assertEquals(0, constraint.getMaxCount());
  73   }
  74
  75   @Test(expected = MalformedPatternException.class)
  76   public void testOverflow() {
  77     test("'a{2147483648}");
  78   }
  79
  80   @Test(expected = MalformedPatternException.class)
  81   public void testMissingBrace() {
  82     test("'a{1,3");
  83   }
  84
  85   @Test(expected = MalformedPatternException.class)
  86   public void testNoOptions() {
  87     test("'a:");
  88   }
  89
  90   @Test
  91   public void testColon() {
  92     test("for('_t 'a : '_b) {}");
  93     assertEquals("for($t$ $a$ : $b$) {}", myOptions.getSearchPattern());
  94   }
  95
  96   @Test(expected = MalformedPatternException.class)
  97   public void testNoOptions2() {
  98     test("'a:+");
  99   }
 100
 101   @Test(expected = MalformedPatternException.class)
 102   public void testUnclosedCondition() {
 103     test("'a:[");
 104   }
 105
 106   @Test(expected = MalformedPatternException.class)
 107   public void testClosedCondition() {
 108     test("'a:[]");
 109   }
 110
 111   @Test(expected = MalformedPatternException.class)
 112   public void testEmptyNegated() {
 113     test("'a:[!]");
 114   }
 115
 116   @Test(expected = UnsupportedPatternException.class)
 117   public void testCondition() {
 118     test("'a:[aap()]");
 119   }
 120
 121   @Test(expected = MalformedPatternException.class)
 122   public void testIncompleteCondition() {
 123     test("'a:[regex(]");
 124   }
 125
 126   @Test(expected = MalformedPatternException.class)
 127   public void testIncompleteCondition2() {
 128     test("'a:[regex()]");
 129   }
 130
 131   @Test(expected = MalformedPatternException.class)
 132   public void testIncompleteMultipleCondition() {
 133     test("'a:[regex( a ) &&]");
 134   }
 135
 136   @Test(expected = MalformedPatternException.class)
 137   public void testInvalidRegularExpression() {
 138     test("'a:x!(");
 139   }
 140
 141   @Test(expected = MalformedPatternException.class)
 142   public void testRepeatingConstraints() {
 143     test("'a*:foo 'a+:[regex( bla )]");
 144   }
 145
 146   @Test(expected = MalformedPatternException.class)
 147   public void testRepeatingConstraints2() {
 148     test("'a:foo 'a*");
 149   }
 150
 151   @Test
 152   public void testMethodReference() {
 153     test("'_a::'_b");
 154     assertEquals("$a$::$b$", myOptions.getSearchPattern());
 155   }
 156
 157   @Test
 158   public void testCompleteMatchConditions() {
 159     test("[within( \"if('_a) { 'st*; }\" )]1+1");
 160     assertEquals("1+1", myOptions.getSearchPattern());
 161     final MatchVariableConstraint constraint = myOptions.getVariableConstraint(Configuration.CONTEXT_VAR_NAME);
 162     assertEquals("\"if('_a) { 'st*; }\"", constraint.getWithinConstraint());
 163   }
 164
 165   @Test(expected = MalformedPatternException.class)
 166   public void testBadWithin() {
 167     test("'_type 'a:[within( \"if ('_a) { '_st*; }\" )] = '_b;");
 168   }
 169
 170   @Test
 171   public void testNestedPatterns() {
 172     test("[within( \"if ('_a:[regex( .*e.* )]) { '_st*; }\" )]'_type 'a = '_b;");
 173     assertEquals("$type$ $a$ = $b$;", myOptions.getSearchPattern());
 174     final MatchVariableConstraint constraint = myOptions.getVariableConstraint(Configuration.CONTEXT_VAR_NAME);
 175     assertEquals("\"if ('_a:[regex( .*e.* )]) { '_st*; }\"", constraint.getWithinConstraint());
 176
 177     test("[!within( \"<'_tag:[regex( ul|ol )] />\" )]<li />");
 178     assertEquals("<li />", myOptions.getSearchPattern());
 179     final MatchVariableConstraint constraint2 = myOptions.getVariableConstraint(Configuration.CONTEXT_VAR_NAME);
 180     assertEquals("\"<'_tag:[regex( ul|ol )] />\"", constraint2.getWithinConstraint());
 181     assertTrue(constraint2.isInvertWithinConstraint());
 182
 183     test("[within( \"if ('_a:[regex( \".*\" )]) { '_st*; }\" )]'_type 'a = '_b;");
 184     assertEquals("$type$ $a$ = $b$;", myOptions.getSearchPattern());
 185     final MatchVariableConstraint constraint3 = myOptions.getVariableConstraint(Configuration.CONTEXT_VAR_NAME);
 186     assertEquals("\"if ('_a:[regex( \".*\" )]) { '_st*; }\"", constraint3.getWithinConstraint());
 187   }
 188
 189   @Test
 190   public void testEscaping() {
 191     test("\\[within( \"if ('_a) { '_st*; }\" )]");
 192     assertEquals("[within( \"if ($a$) { $st$; }\" )]", myOptions.getSearchPattern());
 193     test("\\[");
 194     assertEquals("[", myOptions.getSearchPattern());
 195     test("\\'aaa");
 196     assertEquals("'aaa", myOptions.getSearchPattern());
 197     test("'a\\:");
 198     assertEquals("$a$:", myOptions.getSearchPattern());
 199   }
 200
 201   @Test
 202   public void testQuotes() {
 203     test("''");
 204     assertEquals("'", myOptions.getSearchPattern());
 205     test("'''c");
 206     assertEquals("'$c$", myOptions.getSearchPattern());
 207     test("'a''b");
 208     assertEquals("'a'$b$", myOptions.getSearchPattern());
 209     test("'aa'_bb");
 210     assertEquals("$aa$$bb$", myOptions.getSearchPattern());
 211     test("'\\n''z");
 212     assertEquals("'\\n'$z$", myOptions.getSearchPattern());
 213     test("'\\u0123''a");
 214     assertEquals("'\\u0123'$a$", myOptions.getSearchPattern());
 215   }
 216
 217   @Test
 218   public void testComplexRegexes() {
 219     test("'_t:[regex( *Object\\[\\] ) ] '_t2");
 220     assertEquals("$t$ $t2$", myOptions.getSearchPattern());
 221     final MatchVariableConstraint constraint = myOptions.getVariableConstraint("t");
 222     assertTrue(constraint.isWithinHierarchy());
 223     assertEquals("Object\\[\\]", constraint.getRegExp());
 224
 225     test("// 'Comment:[regex( .*(?:comment).* )]");
 226     assertEquals("// $Comment$", myOptions.getSearchPattern());
 227     final MatchVariableConstraint constraint1 = myOptions.getVariableConstraint("Comment");
 228     assertEquals(".*(?:comment).*", constraint1.getRegExp());
 229   }
 230
 231   @Test
 232   public void testInvert() {
 233     test("'a:[!read&&write]");
 234     assertEquals("$a$", myOptions.getSearchPattern());
 235     final MatchVariableConstraint constraint = myOptions.getVariableConstraint("a");
 236     assertTrue(constraint.isReadAccess());
 237     assertTrue(constraint.isInvertReadAccess());
 238     assertTrue(constraint.isWriteAccess());
 239     assertFalse(constraint.isInvertWriteAccess());
 240   }
 241
 242   @Test(expected = MalformedPatternException.class)
 243   public void testAmpersandsExpected() {
 244     test("'a:[read write]");
 245   }
 246
 247   @Test(expected = MalformedPatternException.class)
 248   public void testUnexpectedAmpersands() {
 249     test("'a:[&&read]");
 250   }
 251
 252   @Test(expected = MalformedPatternException.class)
 253   public void testUnbalancedSpacesSurroundingContent() {
 254     test("'a:[regex(  .* ) ]");
 255   }
 256
 257   @Test(expected = MalformedPatternException.class)
 258   public void testInvalidRegex() {
 259     test("'T:{ ;");
 260   }
 261
 262   @Test
 263   public void testNoSpacesSurroundingRegexNeeded() {
 264     test("'t:[regex(a)]");
 265     final MatchVariableConstraint constraint = myOptions.getVariableConstraint("t");
 266     assertEquals("a", constraint.getRegExp());
 267   }
 268
 269   private void test(String pattern) {
 270     myOptions.setSearchPattern(pattern);
 271     StringToConstraintsTransformer.transformOldPattern(myOptions);
 272   }
 273 }