testing/mocking/AndroidMockGeneratorTest.java

/*
 * Copyright 2010 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.android.testing.mocking;

import javassist.CannotCompileException;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.NotFoundException;

import junit.framework.TestCase;

import java.io.IOException;
import java.lang.reflect.Method;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;


/**
 * Tests for the AndroidMockGenerator class.
 *
 * @author swoodward@google.com (Stephen Woodward)
 */
public class AndroidMockGeneratorTest extends TestCase {
  private AndroidMockGenerator getAndroidMockGenerator() {
    return new AndroidMockGenerator();
  }

  private NoFileAndroidMockGenerator getNoFileMockGenerator() {
    return new NoFileAndroidMockGenerator();
  }

  private void cleanupGeneratedClasses(CtClass... classes) {
    for (CtClass clazz : classes) {
      clazz.detach();
    }
  }

  private <T> void assertUnorderedContentsSame(Iterable<T> expected, Iterable<T> actual) {
    List<T> missingItems = new ArrayList<T>();
    List<T> extraItems = new ArrayList<T>();
    for (T item : expected) {
      missingItems.add(item);
    }
    for (T item : actual) {
      missingItems.remove(item);
      extraItems.add(item);
    }
    for (T item : expected) {
      extraItems.remove(item);
    }
    if (missingItems.size() + extraItems.size() != 0) {
      String errorMessage =
          "Contents were different. Missing: " + Arrays.toString(missingItems.toArray())
              + " Extra: " + Arrays.toString(extraItems.toArray());
      fail(errorMessage);
    }
  }

  private List<String> getExpectedNamesForNumberClass() {
    return getExpectedNamesForNumberClass(false);
  }

  private List<String> getExpectedNamesForObjectClass() {
    List<String> expectedNames = new ArrayList<String>();
    expectedNames.addAll(Arrays.asList(new String[] {"clone", "finalize"}));
    return expectedNames;
  }

  private List<String> getExpectedNamesForNumberClass(boolean includeDelegateMethods) {
    List<String> expectedNames = getExpectedNamesForObjectClass();
    expectedNames.addAll(Arrays.asList(new String[] {"byteValue", "doubleValue", "floatValue",
        "intValue", "longValue", "shortValue"}));
    if (includeDelegateMethods) {
      expectedNames.addAll(Arrays.asList(new String[] {"getDelegate___AndroidMock",
          "setDelegate___AndroidMock"}));
    }
    return expectedNames;
  }

  private List<String> getExpectedNamesForBigIntegerClass() {
    List<String> expectedNames = getExpectedNamesForNumberClass();
    expectedNames.addAll(Arrays.asList(new String[] {"abs", "add", "and", "andNot", "bitCount",
        "bitLength", "clearBit", "compareTo", "divide", "divideAndRemainder", "flipBit", "gcd",
        "getLowestSetBit", "isProbablePrime", "max", "min", "mod", "modInverse", "modPow",
        "multiply", "negate", "nextProbablePrime", "not", "or", "pow", "remainder", "setBit",
        "shiftLeft", "shiftRight", "signum", "subtract", "testBit", "toByteArray", "toString",
        "xor"}));
    return expectedNames;
  }

  private List<String> getMethodNames(CtMethod[] methods) {
    List<String> methodNames = new ArrayList<String>();
    for (CtMethod method : methods) {
      methodNames.add(method.getName());
    }
    return methodNames;
  }

  private List<String> getClassNames(List<GeneratedClassFile> classes) {
    List<String> classNames = new ArrayList<String>();
    for (GeneratedClassFile clazz : classes) {
      classNames.add(clazz.getClassName());
    }
    return classNames;
  }

  private List<String> getExpectedSignaturesForBigIntegerClass() {
    List<String> expectedNames = new ArrayList<String>();
    expectedNames.addAll(Arrays.asList(new String[] {
        "public int java.math.BigInteger.getLowestSetBit()",
        "public java.math.BigInteger java.math.BigInteger.abs()",
        "protected void java.lang.Object.finalize() throws java.lang.Throwable",
        "public java.math.BigInteger java.math.BigInteger.modPow(java.math.BigInteger,"
            + "java.math.BigInteger)",
        "protected native java.lang.Object java.lang.Object.clone() throws "
            + "java.lang.CloneNotSupportedException",
        "public java.math.BigInteger java.math.BigInteger.setBit(int)",
        "public java.math.BigInteger java.math.BigInteger.shiftRight(int)",
        "public int java.math.BigInteger.bitLength()",
        "public java.math.BigInteger java.math.BigInteger.not()",
        "public java.math.BigInteger java.math.BigInteger.subtract(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.flipBit(int)",
        "public boolean java.math.BigInteger.isProbablePrime(int)",
        "public java.math.BigInteger java.math.BigInteger.add(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.modInverse(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.clearBit(int)",
        "public java.math.BigInteger java.math.BigInteger.multiply(java.math.BigInteger)",
        "public byte java.lang.Number.byteValue()",
        "public java.math.BigInteger java.math.BigInteger.gcd(java.math.BigInteger)",
        "public float java.math.BigInteger.floatValue()",
        "public java.lang.String java.math.BigInteger.toString(int)",
        "public java.math.BigInteger java.math.BigInteger.min(java.math.BigInteger)",
        "public int java.math.BigInteger.intValue()",
        "public java.math.BigInteger java.math.BigInteger.or(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.remainder(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.divide(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.xor(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.and(java.math.BigInteger)",
        "public int java.math.BigInteger.signum()",
        "public java.math.BigInteger[] java.math.BigInteger.divideAndRemainder("
            + "java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.max(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.shiftLeft(int)",
        "public double java.math.BigInteger.doubleValue()",
        "public java.math.BigInteger java.math.BigInteger.pow(int)",
        "public short java.lang.Number.shortValue()",
        "public java.math.BigInteger java.math.BigInteger.andNot(java.math.BigInteger)",
        "public byte[] java.math.BigInteger.toByteArray()",
        "public java.math.BigInteger java.math.BigInteger.negate()",
        "public int java.math.BigInteger.compareTo(java.math.BigInteger)",
        "public boolean java.math.BigInteger.testBit(int)",
        "public int java.math.BigInteger.bitCount()",
        "public long java.math.BigInteger.longValue()",
        "public java.math.BigInteger java.math.BigInteger.mod(java.math.BigInteger)",
        "public java.math.BigInteger java.math.BigInteger.nextProbablePrime()",
        }));
    return expectedNames;
  }

  private List<String> getMethodSignatures(Method[] methods) {
    List<String> methodSignatures = new ArrayList<String>();
    for (Method method : methods) {
      if (getAndroidMockGenerator().isMockable(method)) {
        methodSignatures.add(method.toGenericString());
      }
    }
    return methodSignatures;
  }

  public void testIsSupportedType() {
    Class<?>[] unsupportedClasses =
        new Class[] {ClassIsAnnotation.class, ClassIsEnum.class, ClassIsFinal.class,
            ClassIsInterface.class};
    Class<?>[] supportedClasses = new Class[] {Object.class};

    for (Class<?> clazz : unsupportedClasses) {
      assertFalse(getAndroidMockGenerator().classIsSupportedType(clazz));
    }
    for (Class<?> clazz : supportedClasses) {
      assertTrue(getAndroidMockGenerator().classIsSupportedType(clazz));
    }
  }

  public void testGetDelegateFieldName() {
    assertEquals("delegateMockObject", getAndroidMockGenerator().getDelegateFieldName());
  }

  public void testGetInterfaceMethodSource() throws SecurityException, NoSuchMethodException {
    Method method = Object.class.getMethod("equals", Object.class);
    assertEquals("public boolean equals(java.lang.Object arg0);", getAndroidMockGenerator()
        .getInterfaceMethodSource(method));
  }

  public void testGetInterfaceMethodSourceMultipleExceptions() throws SecurityException,
      NoSuchMethodException {
    Method method = Class.class.getDeclaredMethod("newInstance");
    assertEquals("public java.lang.Object newInstance() throws java.lang.InstantiationException,"
        + "java.lang.IllegalAccessException;", getAndroidMockGenerator().getInterfaceMethodSource(
        method));
  }

  public void testGetInterfaceMethodSourceProtectedMethod() throws SecurityException,
      NoSuchMethodException {
    Method method = Object.class.getDeclaredMethod("finalize");
    assertEquals("public void finalize() throws java.lang.Throwable;", getAndroidMockGenerator()
        .getInterfaceMethodSource(method));
  }

  public void testGetInterfaceMethodSourceNoParams() throws SecurityException,
      NoSuchMethodException {
    Method method = Object.class.getMethod("toString");
    assertEquals("public java.lang.String toString();", getAndroidMockGenerator()
        .getInterfaceMethodSource(method));
  }

  public void testGetInterfaceMethodSourceVoidReturn() throws SecurityException,
      NoSuchMethodException {
    Method method = Thread.class.getMethod("run");
    assertEquals("public void run();", getAndroidMockGenerator().getInterfaceMethodSource(method));
  }

  public void testGetInterfaceMethodSourceFinal() throws SecurityException, NoSuchMethodException {
    Method method = Object.class.getMethod("notify");
    try {
      getAndroidMockGenerator().getInterfaceMethodSource(method);
      fail("Exception not thrown on a final method");
    } catch (UnsupportedOperationException e) {
      // expected
    }
  }

  public void testGetInterfaceMethodSourceStatic() throws SecurityException, NoSuchMethodException {
    Method method = Thread.class.getMethod("currentThread");
    try {
      getAndroidMockGenerator().getInterfaceMethodSource(method);
      fail("Exception not thrown on a static method");
    } catch (UnsupportedOperationException e) {
      // expected
    }
  }

  public void testGetInterfaceName() {
    AndroidMockGenerator r = getAndroidMockGenerator();
    assertEquals("genmocks.java.lang.ObjectDelegateInterface",
        FileUtils.getInterfaceNameFor(Object.class, SdkVersion.UNKNOWN));
  }

  public void testGetSubclassName() {
    AndroidMockGenerator r = getAndroidMockGenerator();
    assertEquals("genmocks.java.lang.ObjectDelegateSubclass",
        FileUtils.getSubclassNameFor(Object.class, SdkVersion.UNKNOWN));
  }

  public void testGetDelegateMethodSource() throws SecurityException, NoSuchMethodException {
    Method method = Object.class.getMethod("equals", Object.class);
    assertEquals("public boolean equals(java.lang.Object arg0){if(this.delegateMockObject==null){"
        + "return false;}return this.delegateMockObject.equals(arg0);}", getAndroidMockGenerator()
        .getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceAllTypes() throws SecurityException,
      NoSuchMethodException {
    String[] returnTypes =
        new String[] {"boolean", "byte", "short", "int", "long", "char", "float", "double"};
    String[] castTypes =
        new String[] {"false", "(byte)0", "(short)0", "(int)0", "(long)0", "(char)0", "(float)0",
            "(double)0"};
    for (int i = 0; i < returnTypes.length; ++i) {
      Method method = AllTypes.class.getMethod(returnTypes[i] + "Foo");
      assertEquals("public " + returnTypes[i] + " " + returnTypes[i]
          + "Foo(){if(this.delegateMockObject==null){return " + castTypes[i]
          + ";}return this.delegateMockObject." + returnTypes[i] + "Foo();}",
          getAndroidMockGenerator().getDelegateMethodSource(method));
    }
    Method method = AllTypes.class.getMethod("objectFoo");
    assertEquals("public java.lang.Object objectFoo(){if(this.delegateMockObject==null){return "
        + "null;}return this.delegateMockObject.objectFoo();}", getAndroidMockGenerator()
        .getDelegateMethodSource(method));
    method = AllTypes.class.getMethod("voidFoo");
    assertEquals("public void voidFoo(){if(this.delegateMockObject==null){return ;"
        + "}this.delegateMockObject.voidFoo();}", getAndroidMockGenerator()
        .getDelegateMethodSource(method));
  }

  private class AllTypes {
    @SuppressWarnings("unused")
    public void voidFoo() {
    }

    @SuppressWarnings("unused")
    public boolean booleanFoo() {
      return false;
    }

    @SuppressWarnings("unused")
    public byte byteFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public short shortFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public int intFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public long longFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public char charFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public float floatFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public double doubleFoo() {
      return 0;
    }

    @SuppressWarnings("unused")
    public Object objectFoo() {
      return null;
    }
  }

  public void testGetDelegateMethodSourceMultipleExceptions() throws SecurityException,
      NoSuchMethodException {
    Method method = Class.class.getDeclaredMethod("newInstance");
    assertEquals(
        "public java.lang.Object newInstance() throws java.lang.InstantiationException,"
            + "java.lang.IllegalAccessException{if(this.delegateMockObject==null){return null;}"
            + "return this.delegateMockObject.newInstance();}", getAndroidMockGenerator()
            .getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceProtectedMethod() throws SecurityException,
      NoSuchMethodException {
    Method method = Object.class.getDeclaredMethod("finalize");
    assertEquals("public void finalize() throws java.lang.Throwable{if(this.delegateMockObject=="
        + "null){return ;}this.delegateMockObject.finalize();}", getAndroidMockGenerator()
        .getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceMultiParams() throws SecurityException,
      NoSuchMethodException {
    Method method =
        String.class.getMethod("getChars", Integer.TYPE, Integer.TYPE, char[].class, Integer.TYPE);
    assertEquals(
        "public void getChars(int arg0,int arg1,char[] arg2,int arg3){if(this."
            + "delegateMockObject==null){return ;}this.delegateMockObject.getChars(arg0,arg1,arg2,"
            + "arg3);}", getAndroidMockGenerator().getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceNoParams() throws SecurityException,
      NoSuchMethodException {
    Method method = Object.class.getMethod("toString");
    assertEquals(
        "public java.lang.String toString(){if(this.delegateMockObject==null){return null;"
            + "}return this.delegateMockObject.toString();}", getAndroidMockGenerator()
            .getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceVoidReturn() throws SecurityException,
      NoSuchMethodException {
    Method method = Thread.class.getMethod("run");
    assertEquals("public void run(){if(this.delegateMockObject==null){return ;}this."
        + "delegateMockObject.run();}", getAndroidMockGenerator().getDelegateMethodSource(method));
  }

  public void testGetDelegateMethodSourceFinal() throws SecurityException, NoSuchMethodException {
    Method method = Object.class.getMethod("notify");
    try {
      getAndroidMockGenerator().getDelegateMethodSource(method);
      fail("Exception not thrown on a final method");
    } catch (UnsupportedOperationException e) {
      // expected
    }
  }

  public void testGetDelegateMethodSourceStatic() throws SecurityException, NoSuchMethodException {
    Method method = Thread.class.getMethod("currentThread");
    try {
      getAndroidMockGenerator().getDelegateMethodSource(method);
      fail("Exception not thrown on a static method");
    } catch (UnsupportedOperationException e) {
      // expected
    }
  }

  public void testGenerateEmptySubclass() throws ClassNotFoundException, NotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(String.class, SdkVersion.UNKNOWN);
    CtClass generatedClass = getAndroidMockGenerator().generateSkeletalClass(
        String.class, generatedInterface, SdkVersion.UNKNOWN);

    assertEquals("genmocks.java.lang", generatedClass.getPackageName());
    assertEquals("StringDelegateSubclass", generatedClass.getSimpleName());
    assertEquals("java.lang.String", generatedClass.getSuperclass().getName());
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testAddMethods() throws ClassNotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(Number.class, SdkVersion.UNKNOWN);
    CtClass generatedClass =
        mockGenerator.generateSkeletalClass(Number.class, generatedInterface, SdkVersion.UNKNOWN);

    mockGenerator.addMethods(Number.class, generatedClass);

    List<String> expectedNames = getExpectedNamesForNumberClass();
    List<String> actualNames = getMethodNames(generatedClass.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testAddMethodsObjectClass() throws ClassNotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(Object.class, SdkVersion.UNKNOWN);
    CtClass generatedClass =
        mockGenerator.generateSkeletalClass(Object.class, generatedInterface, SdkVersion.UNKNOWN);

    mockGenerator.addMethods(Object.class, generatedClass);

    List<String> expectedNames = getExpectedNamesForObjectClass();
    List<String> actualNames = getMethodNames(generatedClass.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testAddMethodsUsesSuperclass() throws ClassNotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(
        BigInteger.class, SdkVersion.UNKNOWN);
    CtClass generatedClass = mockGenerator.generateSkeletalClass(
        BigInteger.class, generatedInterface, SdkVersion.UNKNOWN);

    mockGenerator.addMethods(BigInteger.class, generatedClass);

    List<String> expectedNames = getExpectedNamesForBigIntegerClass();
    List<String> actualNames = getMethodNames(generatedClass.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testGetAllMethods() throws ClassNotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(
        BigInteger.class, SdkVersion.UNKNOWN);
    CtClass generatedClass = mockGenerator.generateSkeletalClass(
        BigInteger.class, generatedInterface, SdkVersion.UNKNOWN);

    Method[] methods = mockGenerator.getAllMethods(BigInteger.class);

    List<String> expectedNames = getExpectedSignaturesForBigIntegerClass();
    List<String> actualNames = getMethodSignatures(methods);
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testGenerateInterface() {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(Number.class, SdkVersion.UNKNOWN);

    List<String> expectedNames = getExpectedNamesForNumberClass();
    List<String> actualNames = getMethodNames(generatedInterface.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface);
  }

  public void testAddInterfaceMethods() {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = AndroidMockGenerator.getClassPool().makeInterface("testInterface");

    mockGenerator.addInterfaceMethods(Number.class, generatedInterface);

    List<String> expectedNames = getExpectedNamesForNumberClass();
    List<String> actualNames = getMethodNames(generatedInterface.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface);
  }

  public void testGenerateSubclass() throws ClassNotFoundException {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(Number.class, SdkVersion.UNKNOWN);

    CtClass generatedClass =
        mockGenerator.generateSubClass(Number.class, generatedInterface, SdkVersion.UNKNOWN);

    List<String> expectedNames = getExpectedNamesForNumberClass(true);
    List<String> actualNames = getMethodNames(generatedClass.getDeclaredMethods());
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(generatedInterface, generatedClass);
  }

  public void testCreateMockForClass() throws ClassNotFoundException, IOException,
      CannotCompileException, NotFoundException {
    NoFileAndroidMockGenerator mockGenerator = getNoFileMockGenerator();
    List<GeneratedClassFile> classes = mockGenerator.createMocksForClass(Object.class);

    List<String> expectedNames = new ArrayList<String>();
    String subclassName = "genmocks.java.lang.ObjectDelegateSubclass";
    String interfaceName = "genmocks.java.lang.ObjectDelegateInterface";
    expectedNames.addAll(Arrays.asList(new String[] {subclassName,
        interfaceName}));
    List<String> actualNames = getClassNames(classes);
    assertUnorderedContentsSame(expectedNames, actualNames);
    cleanupGeneratedClasses(
        ClassPool.getDefault().get(subclassName),
        ClassPool.getDefault().get(interfaceName));
  }

  public void testGetSetDelegateMethodSource() {
    AndroidMockGenerator mockGenerator = getAndroidMockGenerator();
    CtClass generatedInterface = mockGenerator.generateInterface(Object.class, SdkVersion.UNKNOWN);
    String expectedSource =
        "public void setDelegate___AndroidMock(genmocks.java.lang.ObjectDelegateInterface obj) {"
            + " this.delegateMockObject = obj;}";

    assertEquals(expectedSource, mockGenerator.getSetDelegateMethodSource(generatedInterface));
  }

  public void testIsForbiddenMethod() throws SecurityException, NoSuchMethodException {
    Method[] forbiddenMethods =
        new Method[] {Object.class.getMethod("equals", Object.class),
            Object.class.getMethod("toString"), Object.class.getMethod("hashCode")};
    Method[] allowedMethods = new Method[] {BigInteger.class.getMethod("toString", Integer.TYPE)};
    for (Method method : forbiddenMethods) {
      assertTrue(getAndroidMockGenerator().isForbiddenMethod(method));
    }
    for (Method method : allowedMethods) {
      assertFalse(getAndroidMockGenerator().isForbiddenMethod(method));
    }
  }

  /**
   * Support test class for capturing the names of files that would have been
   * saved to a jar file.
   *
   * @author swoodward@google.com (Stephen Woodward)
   */
  class NoFileAndroidMockGenerator extends AndroidMockGenerator {
    List<CtClass> savedClasses = new ArrayList<CtClass>();

    @Override
    void saveCtClass(CtClass clazz) {
      savedClasses.add(clazz);
    }
  }
}