diff options
Diffstat (limited to 'tests/com/google/android/testing/mocking/AndroidMockTest.java')
| -rw-r--r-- | tests/com/google/android/testing/mocking/AndroidMockTest.java | 927 |
1 files changed, 927 insertions, 0 deletions
diff --git a/tests/com/google/android/testing/mocking/AndroidMockTest.java b/tests/com/google/android/testing/mocking/AndroidMockTest.java new file mode 100644 index 0000000..56fcbb3 --- /dev/null +++ b/tests/com/google/android/testing/mocking/AndroidMockTest.java @@ -0,0 +1,927 @@ +/* + * 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.Modifier; +import javassist.NotFoundException; +import javassist.expr.ExprEditor; +import javassist.expr.MethodCall; + +import junit.framework.TestCase; + +import org.easymock.Capture; +import org.easymock.IAnswer; +import org.easymock.LogicalOperator; +import org.easymock.internal.matchers.Equals; + +import java.io.IOException; +import java.io.InputStream; +import java.io.ObjectInput; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Calendar; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.SimpleTimeZone; +import java.util.Vector; + + +/** + * Tests for the AndroidMock class. + * + * @author swoodward@google.com (Stephen Woodward) + */ +public class AndroidMockTest extends TestCase { + private List<String> notForwardedMethods = + new ArrayList<String>(Arrays.asList(new String[] { + "com.google.android.testing.mocking.AndroidMock.getInterfaceFor(java.lang.Class)", + "com.google.android.testing.mocking.AndroidMock.getSubclassNameFor(java.lang.Class)", + "com.google.android.testing.mocking.AndroidMock.getSubclassFor(java.lang.Class," + + "java.lang.Class,java.lang.Object)", + "com.google.android.testing.mocking.AndroidMock.getInterfaceNameFor(java.lang.Class)", + "com.google.android.testing.mocking.AndroidMock.createStrictMock(" + + "java.lang.Class,java.lang.Object[])", + "com.google.android.testing.mocking.AndroidMock.createStrictMock(" + + "java.lang.String,java.lang.Class,java.lang.Object[])", + "com.google.android.testing.mocking.AndroidMock.createMock(" + + "java.lang.Class,java.lang.Object[])", + "com.google.android.testing.mocking.AndroidMock.createMock(" + + "java.lang.String,java.lang.Class,java.lang.Object[])", + "com.google.android.testing.mocking.AndroidMock.createNiceMock(" + + "java.lang.Class,java.lang.Object[])", + "com.google.android.testing.mocking.AndroidMock.createNiceMock(" + + "java.lang.String,java.lang.Class,java.lang.Object[])"})); + + private CtMethod[] getForwardedMethods() throws NotFoundException { + List<CtMethod> methods = + new ArrayList<CtMethod>(Arrays.asList(getAndroidMockCtClass().getDeclaredMethods())); + // Get a copy for safe removal of elements during iteration. + for (CtMethod method : Arrays.asList(methods.toArray(new CtMethod[0]))) { + if (notForwardedMethods.contains(method.getLongName()) + || !Modifier.isPublic(method.getModifiers())) { + methods.remove(method); + } + } + return methods.toArray(new CtMethod[0]); + } + + private CtClass getAndroidMockCtClass() throws NotFoundException { + return ClassPool.getDefault().get("com.google.android.testing.mocking.AndroidMock"); + } + + private void compileClasses(List<GeneratedClassFile> mockClasses) throws NotFoundException { + for (GeneratedClassFile clazz : mockClasses) { + CtClass ctClass; + ctClass = ClassPool.getDefault().get(clazz.getClassName()); + try { + ctClass.toClass(); + } catch (CannotCompileException e) { + // Just ignore -- this will happen for every class used in more than one test. + } + } + } + + public void testIsUnboxableToPrimitiveAllPrimitives() { + assertTrue(AndroidMock.isUnboxableToPrimitive(Integer.TYPE, new Integer(42), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Long.TYPE, new Long(42L), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Short.TYPE, new Short((short) 42), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Byte.TYPE, new Byte((byte) 42), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Boolean.TYPE, Boolean.TRUE, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Float.TYPE, new Float(42.0f), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Double.TYPE, new Double(42.0), true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Character.TYPE, new Character('a'), true)); + + assertTrue(AndroidMock.isUnboxableToPrimitive(Integer.TYPE, 42, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Long.TYPE, 42L, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Short.TYPE, (short) 42, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Byte.TYPE, (byte) 42, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Boolean.TYPE, true, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Float.TYPE, 42.0f, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Double.TYPE, 42.0, true)); + assertTrue(AndroidMock.isUnboxableToPrimitive(Character.TYPE, 'a', true)); + } + + public void testIsUnboxableToPrimitiveIsObject() { + assertFalse(AndroidMock.isUnboxableToPrimitive(Integer.TYPE, new Object(), false)); + } + + public void testIsUnboxableToPrimitiveAllWideningPrimitives() { + Object[] testValues = + new Object[] {new Byte((byte) 42), new Short((short) 42), new Integer(42), new Long(42L), + new Float(42.0f), new Double(42.0), new Character('a'), Boolean.TRUE}; + boolean[] byteExpected = new boolean[] {true, false, false, false, false, false, false, false}; + boolean[] shortExpected = new boolean[] {true, true, false, false, false, false, true, false}; + boolean[] intExpected = new boolean[] {true, true, true, false, false, false, true, false}; + boolean[] longExpected = new boolean[] {true, true, true, true, false, false, true, false}; + boolean[] floatExpected = new boolean[] {true, true, true, false, true, false, true, false}; + boolean[] doubleExpected = new boolean[] {true, true, true, true, true, true, true, false}; + boolean[] charExpected = new boolean[] {true, true, true, false, false, false, true, false}; + boolean[] booleanExpected = + new boolean[] {false, false, false, false, false, false, false, true}; + + for (int i = 0; i < testValues.length; ++i) { + assertEquals("Convert byte from " + testValues[i].getClass(), byteExpected[i], AndroidMock + .isUnboxableToPrimitive(Byte.TYPE, testValues[i], false)); + assertEquals("Convert short from " + testValues[i].getClass(), shortExpected[i], AndroidMock + .isUnboxableToPrimitive(Short.TYPE, testValues[i], false)); + assertEquals("Convert int from " + testValues[i].getClass(), intExpected[i], AndroidMock + .isUnboxableToPrimitive(Integer.TYPE, testValues[i], false)); + assertEquals("Convert long from " + testValues[i].getClass(), longExpected[i], AndroidMock + .isUnboxableToPrimitive(Long.TYPE, testValues[i], false)); + assertEquals("Convert float from " + testValues[i].getClass(), floatExpected[i], AndroidMock + .isUnboxableToPrimitive(Float.TYPE, testValues[i], false)); + assertEquals("Convert double from " + testValues[i].getClass(), doubleExpected[i], + AndroidMock.isUnboxableToPrimitive(Double.TYPE, testValues[i], false)); + assertEquals("Convert char from " + testValues[i].getClass(), charExpected[i], AndroidMock + .isUnboxableToPrimitive(Character.TYPE, testValues[i], false)); + assertEquals("Convert boolean from " + testValues[i].getClass(), booleanExpected[i], + AndroidMock.isUnboxableToPrimitive(Boolean.TYPE, testValues[i], false)); + } + } + + + public void testIsUnboxableToPrimitiveNotPrimitive() { + try { + AndroidMock.isUnboxableToPrimitive(Object.class, Object.class, false); + fail("Exception should have been thrown"); + } catch (IllegalArgumentException e) { + // expected + } + } + + public void testCreateMock() throws ClassNotFoundException, IOException, CannotCompileException, + NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateMockUsingParameters() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createMock(SimpleTimeZone.class, 0, "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateMockUsingProtectedConstructors() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Calendar.class); + compileClasses(mockClasses); + Calendar mockCalendar = AndroidMock.createMock(Calendar.class); + AndroidMock.expect(mockCalendar.getGreatestMinimum(1)).andReturn(42); + AndroidMock.replay(mockCalendar); + assertEquals(42, mockCalendar.getGreatestMinimum(1)); + AndroidMock.verify(mockCalendar); + + // Just don't explode + Calendar newMockCalendar = + AndroidMock.createMock(Calendar.class, new SimpleTimeZone(1, "GMT"), Locale.UK); + } + + public void testCreateMockUsingCastableParameters() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createMock(SimpleTimeZone.class, 'a', "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateMockUsingUnusableParameters() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + compileClasses(mockClasses); + try { + SimpleTimeZone mockTimeZone = AndroidMock.createMock(SimpleTimeZone.class, "GMT"); + fail("Excepted an IllegalArgumentException for incorrect number of constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = AndroidMock.createMock(SimpleTimeZone.class, 0, null); + fail("Excepted an IllegalArgumentException for indeterminate null constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = AndroidMock.createMock(SimpleTimeZone.class, 0, new Object()); + fail("Excepted an IllegalArgumentException for incorrect constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + } + + public void testCreateMockUsingInterface() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Map.class); + compileClasses(mockClasses); + Map<String, String> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get("key")).andReturn("Hello World"); + AndroidMock.replay(mockMap); + assertEquals("Hello World", mockMap.get("key")); + AndroidMock.verify(mockMap); + } + + public void testCreateMockUsingClass() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateNiceMock() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createNiceMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateNiceMockUsingUnusableParameters() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + compileClasses(mockClasses); + try { + SimpleTimeZone mockTimeZone = AndroidMock.createNiceMock(SimpleTimeZone.class, "GMT"); + fail("Excepted an IllegalArgumentException for incorrect number of constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = AndroidMock.createNiceMock(SimpleTimeZone.class, 0, null); + fail("Excepted an IllegalArgumentException for indeterminate null constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = + AndroidMock.createNiceMock(SimpleTimeZone.class, 0, new Object()); + fail("Excepted an IllegalArgumentException for incorrect constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + } + + public void testCreateNiceMockUsingParameters() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createNiceMock(SimpleTimeZone.class, 0, "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateNiceMockUsingCastableParameters() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createNiceMock(SimpleTimeZone.class, 'a', "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateNiceMockUsingInterface() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Map.class); + + compileClasses(mockClasses); + Map<String, String> mockMap = AndroidMock.createNiceMock(Map.class); + AndroidMock.expect(mockMap.get("key")).andReturn("Hello World"); + AndroidMock.replay(mockMap); + assertEquals("Hello World", mockMap.get("key")); + AndroidMock.verify(mockMap); + } + + public void testCreateNiceMockUsingClass() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createNiceMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateStrictMock() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createStrictMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateStrictMockUsingUnusableParameters() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + + compileClasses(mockClasses); + try { + SimpleTimeZone mockTimeZone = AndroidMock.createStrictMock(SimpleTimeZone.class, "GMT"); + fail("Excepted an IllegalArgumentException for incorrect number of constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = AndroidMock.createStrictMock(SimpleTimeZone.class, 0, null); + fail("Excepted an IllegalArgumentException for indeterminate null constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + try { + SimpleTimeZone mockTimeZone = + AndroidMock.createStrictMock(SimpleTimeZone.class, 0, new Object()); + fail("Excepted an IllegalArgumentException for incorrect constructor parameters"); + } catch (IllegalArgumentException e) { + // Expected + } + } + + public void testCreateStrictMockUsingParameters() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createStrictMock(SimpleTimeZone.class, 0, "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateStrictMockUsingCastableParameters() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(SimpleTimeZone.class); + + compileClasses(mockClasses); + SimpleTimeZone mockTimeZone = AndroidMock.createStrictMock(SimpleTimeZone.class, 'a', "GMT"); + AndroidMock.expect(mockTimeZone.getRawOffset()).andReturn(42); + AndroidMock.replay(mockTimeZone); + assertEquals(42, mockTimeZone.getRawOffset()); + AndroidMock.verify(mockTimeZone); + } + + public void testCreateStrictMockUsingInterface() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Map.class); + + compileClasses(mockClasses); + Map<String, String> mockMap = AndroidMock.createStrictMock(Map.class); + AndroidMock.expect(mockMap.get("key")).andReturn("Hello World"); + AndroidMock.replay(mockMap); + assertEquals("Hello World", mockMap.get("key")); + AndroidMock.verify(mockMap); + } + + public void testCreateStrictMockUsingClass() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<String> mockVector = AndroidMock.createStrictMock(Vector.class); + AndroidMock.expect(mockVector.get(0)).andReturn("Hello World"); + AndroidMock.replay(mockVector); + assertEquals("Hello World", mockVector.get(0).toString()); + AndroidMock.verify(mockVector); + } + + public void testCreateMockConstructorDoesWorkOnAllReturnTypes() throws ClassNotFoundException, + IOException, CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(ClassDoesWorkInConstructor.class); + compileClasses(mockClasses); + ClassDoesWorkInConstructor mock = AndroidMock.createMock(ClassDoesWorkInConstructor.class); + } + + public void testAllForwardedMethods() throws CannotCompileException, NotFoundException { + for (CtMethod method : getForwardedMethods()) { + MethodVerifier verifier = new MethodVerifier(method); + // CtMethod.instrument Causes every instruction in the method to be + // inspected, and passed to + // the MethodVerifier callback (extends javassist.expr.ExprEditor). We + // want to verify that + // the expected EasyMock method is called at least once in each + // AndroidMock method. + method.instrument(verifier); + assertTrue(method.getLongName() + " not called.", verifier.expectedMethodCalled()); + } + } + + public void testCheckOrder() throws ClassNotFoundException, IOException, CannotCompileException, + NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.checkOrder(mockVector, false); + AndroidMock.checkOrder(AndroidMock.createMock(Map.class), false); + } + + public void testVerify() throws ClassNotFoundException, IOException, CannotCompileException, + NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.replay(mockVector); + AndroidMock.verify(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.replay(mockMap); + AndroidMock.verify(mockMap); + } + + public void testResetToStrict() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.resetToStrict(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.resetToStrict(mockMap); + } + + public void testResetToDefault() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.resetToDefault(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.resetToDefault(mockMap); + } + + public void testResetToNice() throws ClassNotFoundException, IOException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.resetToNice(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.resetToNice(mockMap); + } + + public void testReset() throws ClassNotFoundException, IOException, CannotCompileException, + NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.reset(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.reset(mockMap); + + } + + public void testReplay() throws ClassNotFoundException, IOException, CannotCompileException, + NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(Vector.class); + compileClasses(mockClasses); + Vector<?> mockVector = AndroidMock.createMock(Vector.class); + AndroidMock.replay(mockVector); + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.replay(mockMap); + } + + public void testExpect() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + mockMap.clear(); + AndroidMock.expect(null); + AndroidMock.replay(mockMap); + } + + public void testExpectLastCall() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + mockMap.clear(); + AndroidMock.expectLastCall(); + AndroidMock.replay(mockMap); + } + + public void testAnyBoolean() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyBoolean())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyByte() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyByte())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyChar() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyChar())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyInt() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyInt())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyLong() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyLong())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyFloat() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyFloat())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyDouble() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyDouble())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyShort() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyShort())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnyObject() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.anyObject())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testGeq() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.geq((byte) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq((short) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq(0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq(0L))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq(0.0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq(0.0f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.geq("Hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testLeq() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.leq((byte) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq((short) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq(0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq(0L))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq(0.0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq(0.0f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.leq("Hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testGt() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.gt((byte) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt((short) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt(0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt(0L))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt(0.0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt(0.0f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.gt("Hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testLt() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.lt((byte) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt((short) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt(0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt(0L))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt(0.0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt(0.0f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.lt("Hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testIsA() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.isA(String.class))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testContains() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.contains("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAnd() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq(true), AndroidMock.eq(true)))) + .andReturn(null); + AndroidMock.expect( + mockMap.get(AndroidMock.and(AndroidMock.eq((byte) 0), AndroidMock.eq((byte) 0)))) + .andReturn(null); + AndroidMock.expect( + mockMap.get(AndroidMock.and(AndroidMock.eq((short) 0), AndroidMock.eq((short) 0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq(0), AndroidMock.eq(0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq(0L), AndroidMock.eq(0L)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq(0.0), AndroidMock.eq(0.0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq(0.0f), AndroidMock.eq(0.0f)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq("hi"), AndroidMock.eq("hi")))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.and(AndroidMock.eq('a'), AndroidMock.eq('a')))) + .andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testOr() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq(true), AndroidMock.eq(true)))) + .andReturn(null); + AndroidMock.expect( + mockMap.get(AndroidMock.or(AndroidMock.eq((byte) 0), AndroidMock.eq((byte) 0)))) + .andReturn(null); + AndroidMock.expect( + mockMap.get(AndroidMock.or(AndroidMock.eq((short) 0), AndroidMock.eq((short) 0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq(0), AndroidMock.eq(0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq(0L), AndroidMock.eq(0L)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq(0.0), AndroidMock.eq(0.0)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq(0.0f), AndroidMock.eq(0.0f)))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq("hi"), AndroidMock.eq("hi")))) + .andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.or(AndroidMock.eq('a'), AndroidMock.eq('a')))) + .andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testNot() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq(true)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq((byte) 0)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq((short) 0)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq(0)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq(0L)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq(0.0)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq(0.0f)))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq("hi")))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.not(AndroidMock.eq('a')))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testEq() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.eq(true))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq((byte) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq((short) 0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0L))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0.0))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0.0f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0.0, 0.1))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq(0.0f, 0.1f))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq("hi"))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.eq('a'))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testAryEq() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new boolean[] {true}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new byte[] {(byte) 0}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new short[] {(short) 0}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new int[] {0}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new long[] {0L}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new double[] {0.0}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new float[] {0.0f}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new String[] {"hi"}))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.aryEq(new char[] {'a'}))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testIsNull() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.isNull())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testNotNull() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.notNull())).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testFind() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.find("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testMatches() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.matches("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testStartsWith() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.startsWith("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testEndsWith() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.endsWith("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testSame() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.same("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testCmpEq() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.cmpEq("hi"))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testCmp() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect( + mockMap.get(AndroidMock.cmp("hi", String.CASE_INSENSITIVE_ORDER, LogicalOperator.EQUAL))) + .andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testCapture() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Byte>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Character>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Double>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Float>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Integer>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<Long>()))).andReturn(null); + AndroidMock.expect(mockMap.get(AndroidMock.capture(new Capture<String>()))).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testReportMatcher() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.reportMatcher(new Equals(null)); + AndroidMock.expect(mockMap.get(null)).andReturn(null); + AndroidMock.replay(mockMap); + } + + public void testGetCurrentArguments() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.expect(mockMap.get(null)).andAnswer(new IAnswer() { + @Override + public Object answer() { + AndroidMock.getCurrentArguments(); + return null; + } + }); + AndroidMock.replay(mockMap); + mockMap.get(null); + } + + public void testMakeThreadSafe() { + Map<?, ?> mockMap = AndroidMock.createMock(Map.class); + AndroidMock.makeThreadSafe(mockMap, false); + AndroidMock.replay(mockMap); + } + + public void testAndThrowsOnMockedInterface() throws IOException { + ObjectInput mockInStream = AndroidMock.createMock(ObjectInput.class); + AndroidMock.expect(mockInStream.read()).andThrow(new IOException("foo")); + AndroidMock.replay(mockInStream); + try { + mockInStream.read(); + fail("IOException not thrown"); + } catch (IOException e) { + assertEquals("foo", e.getMessage()); + } + AndroidMock.verify(mockInStream); + } + + public void testAndThrowsOnMockedClass() throws IOException, ClassNotFoundException, + CannotCompileException, NotFoundException { + List<GeneratedClassFile> mockClasses = + new AndroidMockGenerator().createMocksForClass(InputStream.class); + compileClasses(mockClasses); + InputStream mockInStream = AndroidMock.createMock(InputStream.class); + AndroidMock.expect(mockInStream.read()).andThrow(new IOException("foo")); + AndroidMock.replay(mockInStream); + try { + mockInStream.read(); + fail("IOException not thrown"); + } catch (IOException e) { + assertEquals("foo", e.getMessage()); + } + AndroidMock.verify(mockInStream); + } + + /** + * Used for testing that a given method on Android Mock calls the equivalent + * method on EasyMock, to ensure that the method-wiring of Android Mock is + * correct. + * + * @author swoodward@google.com (Stephen Woodward) + */ + class MethodVerifier extends ExprEditor { + private CtMethod expectedMethod; + private boolean methodCalled; + + MethodVerifier(CtMethod expectedMethod) { + this.expectedMethod = expectedMethod; + } + + @Override + public void edit(MethodCall calledMethod) { + try { + methodCalled = methodCalled || expectedMethod.equals(calledMethod.getMethod()); + } catch (NotFoundException e) { + throw new RuntimeException(e); + } + } + + public boolean expectedMethodCalled() { + return methodCalled; + } + } +} |