/*
 * Copyright 2007 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.test.metric;

import java.io.File;
import java.net.InetAddress;
import java.util.Arrays;
import java.util.BitSet;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;

import com.google.classpath.DirectoryClassPath;
import com.google.test.metric.method.op.turing.Operation;

public class ClassInfoTest extends AutoFieldClearTestCase {

  private final ClassRepository repo = new JavaClassRepository();

  public void testNonExistingClass() throws Exception {
    try {
      repo.getClass("IDontExistClass");
      fail();
    } catch (ClassNotFoundException e) {
      assertTrue(e.getMessage().contains("IDontExistClass"));
      assertEquals("IDontExistClass", e.getClassName());
    }
  }

  public static class EmptyClass {
  }

  public void testParseEmptyClass() throws Exception {
    ClassInfo clazz = repo.getClass(EmptyClass.class.getCanonicalName());
    assertEquals(EmptyClass.class.getCanonicalName(), clazz.getName());
    assertEquals(EmptyClass.class.getCanonicalName(), clazz.toString());
    assertSame(clazz, repo.getClass(EmptyClass.class.getCanonicalName()));
  }

  public void testMethodNotFoundException() throws Exception {
    ClassInfo clazz = repo.getClass(EmptyClass.class.getCanonicalName());
    try {
      clazz.getMethod("IDontExistMethod()V");
      fail();
    } catch (MethodNotFoundException e) {
      assertTrue(e.getMessage().contains("IDontExistMethod()V"));
      assertTrue(e.getMessage().contains(EmptyClass.class.getCanonicalName()));
      assertEquals("IDontExistMethod()V", e.getMethodName());
      assertEquals(clazz, e.getClassInfo());
    }
  }

  public static class SingleMethodClass {
    public void methodA() {
    }
  }

  public void testParseSingleMethodClass() throws Exception {
    ClassInfo clazz = repo.getClass(SingleMethodClass.class.getCanonicalName());
    MethodInfo method = clazz.getMethod("void methodA()");
    assertEquals("void methodA()", method.toString());
    assertSame(method, clazz.getMethod("void methodA()"));
  }

  public void testFiledNotFound() throws Exception {
    ClassInfo clazz = repo.getClass(EmptyClass.class.getCanonicalName());
    try {
      clazz.getField("IDontExistField");
      fail();
    } catch (FieldNotFoundException e) {
      assertTrue(e.getMessage().contains("IDontExistField"));
      assertTrue(e.getMessage().contains(EmptyClass.class.getCanonicalName()));
      assertEquals("IDontExistField", e.getFieldName());
      assertEquals(clazz, e.getClassInfo());
    }
  }

  public static class SingleFieldClass {
    Object fieldA;
  }

  public void testParseFields() throws Exception {
    ClassInfo clazz = repo.getClass(SingleFieldClass.class.getCanonicalName());
    FieldInfo field = clazz.getField("fieldA");
    assertEquals("fieldA", field.getName());
    assertEquals(SingleFieldClass.class.getCanonicalName()
        + ".fieldA{java.lang.Object}", field.toString());
    assertSame(field, clazz.getField("fieldA"));
  }

  public static class LocalVarsClass {
    public void method() {
    }

    public static void staticMethod() {
    }

    public void method3(Object a, int b, int[] c) {
      Object d = null;
      a = d;
    }

    public static void staticMethod3(Object a, int b, int[] c) {
      Object d = null;
      a = d;
    }
  }

  public void testLocalVarsMethod() throws Exception {
    assertLocalVars("void method()", params(), locals("this"));
  }

  public void testLocalVarsStaticMethod() throws Exception {
    assertLocalVars("void staticMethod()", params(), locals());
  }

  public void testLocalVarsMethod3() throws Exception {
    assertLocalVars("void method3(java.lang.Object, int, int[])",
        params("a", "b", "c"), locals("this", "d"));
  }

  public void testLocalVarsStaticMethod3() throws Exception {
    assertLocalVars("void staticMethod3(java.lang.Object, int, int[])", params("a",
        "b", "c"), locals("d"));
  }

  private void assertLocalVars(String method, String[] params, String[] locals) {
    ClassInfo classInfo = repo.getClass(LocalVarsClass.class.getCanonicalName());
    MethodInfo methodInfo = classInfo.getMethod(method);
    List<ParameterInfo> paramsParse = methodInfo.getParameters();
    List<LocalVariableInfo> localsParse = methodInfo.getLocalVariables();
    assertEquals("Expecting " + Arrays.toString(params) + " found "
        + paramsParse, params.length, paramsParse.size());
    assertEquals("Expecting " + Arrays.toString(locals) + " found "
        + localsParse, locals.length, localsParse.size());
    for (int i = 0; i < params.length; i++) {
      assertEquals(params[i], paramsParse.get(i).getName());
    }
    for (int i = 0; i < locals.length; i++) {
      assertEquals(locals[i], localsParse.get(i).getName());
    }
  }

  private String[] params(String... strings) {
    return strings;
  }

  private String[] locals(String... strings) {
    return strings;
  }

  public void testJavaLangObject() throws Exception {
    repo.getClass(Object.class.getCanonicalName());
  }

  public void testJavaLangString() throws Exception {
    repo.getClass(String.class.getCanonicalName());
  }

  public void testJavaUtilBitSet() throws Exception {
    repo.getClass(BitSet.class.getCanonicalName());
  }

  static class BitSetGetMethod {
    private long[] bits;

    public BitSetGetMethod get(int fromIndex, int toIndex) {
      int startBitIndex = 0;
      while (true) {
        bits[0] = bits[1] | (startBitIndex == 2 ? 0 : 2);
      }
    }
  }

  public void testJavaUtilBitSetGetMethod() throws Exception {
    repo.getClass(BitSetGetMethod.class.getCanonicalName());
  }

  private static class Monitor {
    public void method() {
      synchronized (this) {
        hashCode();
      }
    }

    public void method2() {
      hashCode();
      synchronized (this) {
        hashCode();
      }
      hashCode();
    }
  }

  public void testMonitor() throws Exception {
    repo.getClass(Monitor.class.getCanonicalName());
  }

  public void testJSRinstructionInTryCatchFinally() throws Exception {
    repo.getClass(InetAddress.class.getCanonicalName());
  }

  interface TestInterface {
    Object get(Object o);
  }

  interface SubTestInterface extends TestInterface {
  }

  class ImplementsSubTestInterface implements SubTestInterface {
    public Object get(Object o) {
      return null;
    }
  }

  public void testMethodInSuperInterface() throws Exception {
    ClassInfo interfaceClassInfo = repo.getClass(SubTestInterface.class.getCanonicalName());
    assertEquals(repo.getClass(Object.class.getCanonicalName()), interfaceClassInfo.getSuperClass());
    List<ClassInfo> superInterfaces = interfaceClassInfo.getInterfaces();
    assertEquals(1, superInterfaces.size());
    assertEquals(repo.getClass(TestInterface.class.getCanonicalName()), superInterfaces.get(0));
    assertNotNull(interfaceClassInfo.getMethod("java.lang.Object get(java.lang.Object)"));
  }

  public void testPickConcreteMethodOverInterfaceMethod() throws Exception {
    ClassInfo classInfo = repo.getClass(ImplementsSubTestInterface.class.getCanonicalName());
    ClassInfo interfaceClassInfo = repo.getClass(SubTestInterface.class.getCanonicalName());
    MethodInfo method = classInfo.getMethod("java.lang.Object get(java.lang.Object)");
    assertSame(classInfo, method.getClassInfo());
    assertNotSame(interfaceClassInfo, method.getClassInfo());
  }

  public void testReadInvalidByteCodeClassFile() throws Exception {
    ClassRepository repo = new JavaClassRepository(new DirectoryClassPath(new File("classes-for-test")));
    try {
      repo.getClass("invalidByteCode");
      fail();
    } catch (ClassNotFoundException e) {
    }
  }

  public void testGetSettersShouldReturnItemsInAlphabeticalOrderAndIncludeSuperClasses() throws Exception {
    List<ClassInfo> emptyInterfaces = Collections.emptyList();
    ClassInfo superClass = new ClassInfo("super", false, null, emptyInterfaces, null);
    List<ParameterInfo> params = Collections.emptyList();
    List<LocalVariableInfo> locals = Collections.emptyList();
    List<Operation> operations = Collections.emptyList();
    superClass.addMethod(new MethodInfo(superClass, "void setB()", -1, null, params, locals,Visibility.PUBLIC, operations, false, false, Collections.<Integer>emptyList()));
    superClass.addMethod(new MethodInfo(superClass, "void setA()", -1, null, params, locals,Visibility.PRIVATE, operations, false, false, Collections.<Integer>emptyList()));
    superClass.addMethod(new MethodInfo(superClass, "voidX()", -1, null, params, locals,Visibility.PUBLIC, operations, false, false, Collections.<Integer>emptyList()));
    ClassInfo clazz = new ClassInfo("super", false, superClass, emptyInterfaces, null);
    clazz.addMethod(new MethodInfo(clazz, "void setD()", -1, null, params, locals,Visibility.PUBLIC, operations, false, false, Collections.<Integer>emptyList()));
    clazz.addMethod(new MethodInfo(clazz, "void setC()", -1, null, params, locals,Visibility.PUBLIC, operations, false, false, Collections.<Integer>emptyList()));

    Collection<MethodInfo> setters = clazz.getSetters();
    assertEquals(3, setters.size());
    Iterator<MethodInfo> iterator = setters.iterator();
    assertEquals("void setB()", iterator.next().getName());
    assertEquals("void setC()", iterator.next().getName());
    assertEquals("void setD()", iterator.next().getName());
  }

}