StandardPatternsTest.java

/*
 * Copyright (c) 2000-2007 JetBrains s.r.o. All Rights Reserved.
 */
package com.intellij.patterns;

import com.intellij.openapi.util.Key;
import com.intellij.testFramework.UsefulTestCase;
import com.intellij.util.ProcessingContext;

import java.util.Arrays;

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

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

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

  public void testString() throws Throwable {
    final ElementPattern pattern = string();
    assertFalse(string().accepts(new Object()));
    assertTrue(pattern.accepts(""));
  }

  public void testStartsWith() throws Throwable {
    final ElementPattern pattern = string().startsWith("abc");
    assertFalse(pattern.accepts(""));
    assertTrue(pattern.accepts("abcd"));
    assertTrue(pattern.accepts("abc"));

    assertFalse(string().startsWith("abc").accepts(new Object()));
  }

  public void testEndsWith() throws Throwable {
    final ElementPattern pattern = string().endsWith("abc");
    assertFalse(pattern.accepts(""));
    assertFalse(pattern.accepts("abcd"));
    assertTrue(pattern.accepts("abc"));
  }

  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() throws Throwable {
    checkPrefixSuffix(string().endsWith("abc").startsWith("abc"));
  }

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

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

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

  public void testNot1() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    //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() throws Throwable {
    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() throws Throwable {
    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() throws Throwable {
    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));
  }


}