/**
 * Copyright (C) 2006 Google Inc.
 *
 * 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.google.inject.matcher;

import static com.google.inject.Asserts.assertEqualWhenReserialized;
import static com.google.inject.Asserts.assertEqualsBothWays;
import static com.google.inject.matcher.Matchers.annotatedWith;
import static com.google.inject.matcher.Matchers.any;
import static com.google.inject.matcher.Matchers.identicalTo;
import static com.google.inject.matcher.Matchers.inPackage;
import static com.google.inject.matcher.Matchers.inSubpackage;
import static com.google.inject.matcher.Matchers.not;
import static com.google.inject.matcher.Matchers.only;
import static com.google.inject.matcher.Matchers.returns;
import static com.google.inject.matcher.Matchers.subclassesOf;
import com.google.inject.name.Named;
import com.google.inject.name.Names;
import java.io.IOException;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.reflect.Method;
import java.util.AbstractList;
import junit.framework.TestCase;

/**
 * @author crazybob@google.com (Bob Lee)
 */
public class MatcherTest extends TestCase {

  public void testAny() {
    assertTrue(any().matches(null));
    assertEquals("any()", any().toString());
    assertEqualsBothWays(any(), any());
    assertFalse(any().equals(not(any())));
  }

  public void testNot() {
    assertFalse(not(any()).matches(null));
    assertEquals("not(any())", not(any()).toString());
    assertEqualsBothWays(not(any()), not(any()));
    assertFalse(not(any()).equals(any()));
  }

  public void testAnd() {
    assertTrue(any().and(any()).matches(null));
    assertFalse(any().and(not(any())).matches(null));
    assertEquals("and(any(), any())", any().and(any()).toString());
    assertEqualsBothWays(any().and(any()), any().and(any()));
    assertFalse(any().and(any()).equals(not(any())));
  }

  public void testOr() {
    assertTrue(any().or(not(any())).matches(null));
    assertFalse(not(any()).or(not(any())).matches(null));
    assertEquals("or(any(), any())", any().or(any()).toString());
    assertEqualsBothWays(any().or(any()), any().or(any()));
    assertFalse(any().or(any()).equals(not(any())));
  }

  public void testAnnotatedWith() {
    assertTrue(annotatedWith(Foo.class).matches(Bar.class));
    assertFalse(annotatedWith(Foo.class).matches(
        MatcherTest.class.getMethods()[0]));
    assertEquals("annotatedWith(Foo.class)", annotatedWith(Foo.class).toString());
    assertEqualsBothWays(annotatedWith(Foo.class), annotatedWith(Foo.class));
    assertFalse(annotatedWith(Foo.class).equals(annotatedWith(Named.class)));

    try {
      annotatedWith(Baz.class);
      fail();
    } catch (IllegalArgumentException expected) {
    }
  }

  public void testSubclassesOf() {
    assertTrue(subclassesOf(Runnable.class).matches(Runnable.class));
    assertTrue(subclassesOf(Runnable.class).matches(MyRunnable.class));
    assertFalse(subclassesOf(Runnable.class).matches(Object.class));
    assertEquals("subclassesOf(Runnable.class)", subclassesOf(Runnable.class).toString());
    assertEqualsBothWays(subclassesOf(Runnable.class), subclassesOf(Runnable.class));
    assertFalse(subclassesOf(Runnable.class).equals(subclassesOf(Object.class)));
  }

  public void testOnly() {
    assertTrue(only(1000).matches(1000));
    assertFalse(only(1).matches(1000));
    assertEquals("only(1)", only(1).toString());
    assertEqualsBothWays(only(1), only(1));
    assertFalse(only(1).equals(only(2)));
  }

  @SuppressWarnings("UnnecessaryBoxing")
  public void testIdenticalTo() {
    Object o = new Object();
    assertEquals("identicalTo(1)", identicalTo(1).toString());
    assertTrue(identicalTo(o).matches(o));
    assertFalse(identicalTo(o).matches(new Object()));
    assertEqualsBothWays(identicalTo(o), identicalTo(o));
    assertFalse(identicalTo(1).equals(identicalTo(new Integer(1))));
  }

  public void testInPackage() {
    Package matchersPackage = Matchers.class.getPackage();
    assertEquals("inPackage(com.google.inject.matcher)", inPackage(matchersPackage).toString());
    assertTrue(inPackage(matchersPackage).matches(MatcherTest.class));
    assertFalse(inPackage(matchersPackage).matches(Object.class));
    assertEqualsBothWays(inPackage(matchersPackage), inPackage(matchersPackage));
    assertFalse(inPackage(matchersPackage).equals(inPackage(Object.class.getPackage())));
  }

  public void testInSubpackage() {
    String stringPackageName = String.class.getPackage().getName();
    assertEquals("inSubpackage(java.lang)", inSubpackage(stringPackageName).toString());
    assertTrue(inSubpackage(stringPackageName).matches(Object.class));
    assertTrue(inSubpackage(stringPackageName).matches(Method.class));
    assertFalse(inSubpackage(stringPackageName).matches(Matchers.class));
    assertFalse(inSubpackage("jav").matches(Object.class));
    assertEqualsBothWays(inSubpackage(stringPackageName), inSubpackage(stringPackageName));
    assertFalse(inSubpackage(stringPackageName).equals(inSubpackage(Matchers.class.getPackage().getName())));
  }

  public void testReturns() throws NoSuchMethodException {
    Matcher<Method> predicate = returns(only(String.class));
    assertTrue(predicate.matches(
        Object.class.getMethod("toString")));
    assertFalse(predicate.matches(
        Object.class.getMethod("hashCode")));
    assertEquals("returns(only(class java.lang.String))", returns(only(String.class)).toString());
    assertEqualsBothWays(predicate, returns(only(String.class)));
    assertFalse(predicate.equals(returns(only(Integer.class))));
  }
  
  public void testSerialization() throws IOException {
    assertEqualWhenReserialized(any());
    assertEqualWhenReserialized(not(any()));
    assertEqualWhenReserialized(annotatedWith(Named.class));
    assertEqualWhenReserialized(annotatedWith(Names.named("foo")));
    assertEqualWhenReserialized(only("foo"));
    assertEqualWhenReserialized(identicalTo(Object.class));
    assertEqualWhenReserialized(inPackage(String.class.getPackage()));
    assertEqualWhenReserialized(inSubpackage(String.class.getPackage().getName()));
    assertEqualWhenReserialized(returns(any()));
    assertEqualWhenReserialized(subclassesOf(AbstractList.class));
    assertEqualWhenReserialized(only("a").or(only("b")));
    assertEqualWhenReserialized(only("a").and(only("b")));
  }

  static abstract class MyRunnable implements Runnable {}
  
  @Retention(RetentionPolicy.RUNTIME)
  @interface Foo {}

  @Foo
  static class Bar {}

  @interface Baz {}

  @Baz
  static class Car {}
}