platform/platform-tests/testSrc/com/intellij/patterns/StandardPatternsTest.java

/*
 * Copyright 2000-2014 JetBrains s.r.o.
 *
 * 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 com.intellij.patterns;

import com.intellij.openapi.util.Key;
import com.intellij.util.ProcessingContext;
import junit.framework.TestCase;

import java.util.Arrays;

import static com.intellij.patterns.StandardPatterns.*;

/**
 * @author peter
 */
public class StandardPatternsTest extends TestCase {

  public void testNull() {
    assertTrue(object().isNull().accepts(null));
    assertFalse(object().isNull().accepts(""));
    assertFalse(string().isNull().accepts(""));
    assertTrue(string().isNull().accepts(null));
  }

  private static void checkPrefixSuffix(final ElementPattern pattern) {
    assertFalse(pattern.accepts(""));
    assertFalse(pattern.accepts("abcd"));
    assertTrue(pattern.accepts("abc"));
    assertTrue(pattern.accepts("abcdabc"));
    assertFalse(pattern.accepts("abcdab"));
  }

  public void testPrefixSuffix() {
    checkPrefixSuffix(string().endsWith("abc").startsWith("abc"));
  }

  public void testAnd1() {
    checkPrefixSuffix(and(string().endsWith("abc"), string().startsWith("abc")));
  }

  public void testAnd2() {
    checkPrefixSuffix(string().endsWith("abc").and(string().startsWith("abc")));
  }

  public void testOr1() {
    checkOr(or(string().endsWith("abc"), string().startsWith("abc")));
  }

  public void testNot1() {
    final ElementPattern pattern = not(or(string().endsWith("abc"), string().startsWith("abc")));
    assertTrue(pattern.accepts(""));
    assertTrue(pattern.accepts("xxx"));
    assertFalse(pattern.accepts("abcd"));
    assertTrue(pattern.accepts("dabcd"));
    assertFalse(pattern.accepts("abc"));
    assertFalse(pattern.accepts("abcdabc"));
    assertFalse(pattern.accepts("abcdab"));
  }

  private static void checkOr(final ElementPattern filterFactory) {
    assertFalse(filterFactory.accepts(""));
    assertFalse(filterFactory.accepts("xxx"));
    assertTrue(filterFactory.accepts("abcd"));
    assertFalse(filterFactory.accepts("dabcd"));
    assertTrue(filterFactory.accepts("abc"));
    assertTrue(filterFactory.accepts("abcdabc"));
    assertTrue(filterFactory.accepts("abcdab"));
  }

  public void testEquals() {
    final Object foo = new Object();
    final Object bar = new Object();
    ElementPattern objectPattern = object().equalTo(foo);
    assertTrue(objectPattern.accepts(foo));
    assertFalse(objectPattern.accepts(bar));

    ElementPattern stringPattern = string().equalTo("foo");
    assertTrue(stringPattern.accepts("foo"));
    assertFalse(stringPattern.accepts("bar"));
  }


  public void testAll() {
    ElementPattern pattern = collection(String.class).all(string().startsWith("abc"));
    assertTrue(pattern.accepts(Arrays.asList("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "abcd")));
    assertFalse(pattern.accepts(Arrays.asList("abc", "bcd")));
  }

  public void testAtLeastOne() {
    ElementPattern pattern = collection(String.class).atLeastOne(string().startsWith("abc"));
    assertTrue(pattern.accepts(Arrays.asList("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "abcd")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "bcd")));
    assertFalse(pattern.accepts(Arrays.asList("bc", "bcd")));
    assertTrue(pattern.accepts(Arrays.asList("bc", "abc")));
  }

  public void testFilter() {
    ElementPattern pattern =
      collection(String.class).filter(string().endsWith("x"), collection(String.class).all(string().startsWith("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "abcd")));
    assertFalse(pattern.accepts(Arrays.asList("bcx", "bcd")));
    assertTrue(pattern.accepts(Arrays.asList("abcx", "abc")));
  }

  public void testFirst() {
    ElementPattern pattern = collection(String.class).first(string().startsWith("abc"));
    assertFalse(pattern.accepts(Arrays.<String>asList()));
    assertTrue(pattern.accepts(Arrays.asList("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "abcd")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "bcd")));
    assertFalse(pattern.accepts(Arrays.asList("bc", "bcd")));
    assertFalse(pattern.accepts(Arrays.asList("bc", "abc")));
  }

  public void testLast() {
    //collection(String.class)

    ElementPattern pattern = collection(String.class).last(string().startsWith("abc"));
    assertFalse(pattern.accepts(Arrays.<String>asList()));
    assertTrue(pattern.accepts(Arrays.asList("abc")));
    assertTrue(pattern.accepts(Arrays.asList("abc", "abcd")));
    assertFalse(pattern.accepts(Arrays.asList("abc", "bcd")));
    assertFalse(pattern.accepts(Arrays.asList("bc", "bcd")));
    assertTrue(pattern.accepts(Arrays.asList("bc", "abc")));
  }

  public void testSize() {
    final CollectionPattern<String> filter = collection(String.class);
    assertTrue(filter.size(0).accepts(Arrays.<String>asList()));
    assertFalse(filter.size(0).accepts(Arrays.asList("abc")));
    assertFalse(filter.size(0).accepts(Arrays.asList("abc", "abc")));

    assertFalse(filter.size(1).accepts(Arrays.<String>asList()));
    assertTrue(filter.size(1).accepts(Arrays.asList("abc")));
    assertFalse(filter.size(1).accepts(Arrays.asList("abc", "abc")));

    assertFalse(filter.size(2).accepts(Arrays.<String>asList()));
    assertFalse(filter.size(2).accepts(Arrays.asList("abc")));
    assertTrue(filter.size(2).accepts(Arrays.asList("abc", "abc")));
  }

  public void testEmpty() {
    final CollectionPattern<String> filter = collection(String.class);
    assertTrue(filter.empty().accepts(Arrays.<String>asList()));
    assertFalse(filter.empty().accepts(Arrays.asList("abc")));
    assertFalse(filter.empty().accepts(Arrays.asList("abc", "abc")));

    assertFalse(not(filter.empty()).accepts(Arrays.<String>asList()));
    assertTrue(not(filter.empty()).accepts(Arrays.asList("abc")));
    assertTrue(not(filter.empty()).accepts(Arrays.asList("abc", "abc")));
  }

  public void testSave() {
    Key<String> key = Key.create("abc");
    final ProcessingContext context = new ProcessingContext();
    assertFalse(string().contains("abc").save(key).accepts(null));
    assertNull(context.get(key));

    assertFalse(string().contains("abc").save(key).accepts("def"));
    assertNull(context.get(key));

    final String s = "defabcdef";
    assertTrue(string().contains("abc").save(key).accepts(s, context));
    assertSame(s, context.get(key));
  }
}