Android Unit Test Sample

class API{
 public static Banner loadBanner(Request request);
}

class API{
 public static Banner loadBanner(Request request) {
 return Singleton.of(APIImpl.class).loadBanner(request);
 }
}

class API{
 public static Banner loadBanner(Request request) {
 return new BannerJob().loadBanner(request);
 }
}

apply plugin: 'com.android.application'
ext.versions = [
 // Unit test
 junit : '4+',
 robolectric: '3.0',
 powermock : '1.6.2',
 mockito : '1.10.19',
]
android {
 compileSdkVersion 21
 buildToolsVersion "21.0.1"
 compileOptions {
 sourceCompatibility 1.7
 targetCompatibility 1.7
 }
 defaultConfig {
 applicationId "owo.com.androidunittest"
 minSdkVersion 15
 targetSdkVersion 21
 versionCode 1
 versionName "1.0"
 }
 buildTypes {
 release {
 minifyEnabled false
 proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
 }
 }
 dependencies {
 compile fileTree(dir: 'libs', include: ['*.jar'])
 compile 'com.android.support:appcompat-v7:21.0.+'
 // Unit test
 testCompile 'junit:junit:${versions.junit}'
 testCompile "org.robolectric:robolectric:${versions.robolectric}"
 //testCompile "org.robolectric:robolectric:3.1-SNAPSHOT"
 testCompile "org.powermock:powermock-module-junit4:${versions.powermock}"
 testCompile "org.powermock:powermock-module-junit4-rule:${versions.powermock}"
 testCompile "org.powermock:powermock-api-mockito:${versions.powermock}"
 testCompile "org.powermock:powermock-classloading-xstream:${versions.powermock}"
 testCompile "org.mockito:mockito-all:${versions.mockito}"
 testCompile group: 'org.hamcrest', name: 'hamcrest-core', version: '1.3'
 testCompile group: 'org.hamcrest', name: 'hamcrest-library', version: '1.3'
 }
}

 @Test
 public void testAssertArrayEquals() {
 byte[] expected = "trial".getBytes();
 byte[] actual = "trial".getBytes();
 Assert.assertArrayEquals("failure - byte arrays not same", expected, actual);
 }

 @Test
 public void testAssertEquals() {
 Assert.assertEquals("failure - strings are not equal", "text", "text");
 }

 @Test
 public void testAssertFalse() {
 Assert.assertFalse("failure - should be false", false);
 }
 @Test
 public void testAssertTrue() {
 Assert.assertTrue("failure - should be true", true);
 }

 @Test
 public void testAssertNotNull() {
 Assert.assertNotNull("should not be null", new Object());
 }
 @Test
 public void testAssertNull() {
 Assert.assertNull("should be null", null);
 }

 @Test
 public void testAssertNotSame() {
 Assert.assertNotSame("should not be same Object", new Object(), new Object());
 }
 @Test
 public void testAssertSame() {
 Integer aNumber = Integer.valueOf(768);
 Assert.assertSame("should be same", aNumber, aNumber);
 }

 // JUnit Matchers assertThat
 @Test
 public void testAssertThatBothContainsString() {
 assertThat("albumen", allOf(containsString("a"), containsString("b")));
 }
 @Test
 public void testAssertThatHasItems() {
 assertThat(Arrays.asList("one", "two", "three"), hasItems("one", "three"));
 }
 @Test
 public void testAssertThatEveryItemContainsString() {
 assertThat(Arrays.asList(new String[] {"fun", "ban", "net"}), everyItem(containsString("n")));
 }
 // Core Hamcrest Matchers with assertThat
 @Test
 public void testAssertThatHamcrestCoreMatchers() {
 assertThat("good", allOf(equalTo("good"), startsWith("good")));
 assertThat("good", not(allOf(equalTo("bad"), equalTo("good"))));
 assertThat("good", anyOf(equalTo("bad"), equalTo("good")));
 assertThat(7, not(CombinableMatcher.<Integer>either(equalTo(3)).or(equalTo(4))));
 assertThat(new Object(), not(sameInstance(new Object())));
 }

 @Test(expected= IndexOutOfBoundsException.class)
 public void empty() { new ArrayList<Object>().get(0); }

 @Ignore("Test is ignored as a demonstration")
 @Test
 public void testSame() {assertThat(1, is(1));}

 @Test(timeout=1000)
 public void testWithTimeout() {
// while(true){
//
// }
 }

 @Test
 public void filenameIncludesUsername() throws Exception {
 boolean flag = false;
 assumeTrue(flag);
 throw new Exception("flag is true!");
 }

 @Rule
 public TemporaryFolder tempFolder = new TemporaryFolder();
 @Test
 public void countsAssets() throws IOException {
 File icon = tempFolder.newFile("icon.png");
 Assert.assertTrue(icon.exists());
 }

 @Test
 public void testJudgeMock() {
 A a = mock(A.class);
 A b = spy(new A());
 Assert.assertTrue(Mockito.mockingDetails(a).isMock());
 Assert.assertFalse(Mockito.mockingDetails(a).isSpy());
 Assert.assertTrue(Mockito.mockingDetails(b).isMock());
 Assert.assertTrue(Mockito.mockingDetails(b).isSpy());
 }

 @Test
 public void testMock() {
 A a = mock(A.class);
 Mockito.when(a.publicMethod()).thenReturn("mockA");
 Assert.assertEquals("mockA", a.publicMethod());
 Mockito.verify(a, times(1)).publicMethod();
 Mockito.verify(a, never()).foo();
 }

 @Test
 public void testSpy() {
 A a = new A();
 a = Mockito.spy(a);
 Mockito.when(a.publicMethod()).thenReturn("mockA");
 Assert.assertEquals("mockA", a.publicMethod()); // mocked
 Assert.assertEquals("publicMethod2", a.publicMethod2()); // not mocked
 Mockito.verify(a, times(1)).publicMethod();
 }

 @Test(expected = Exception.class)
 public void testThrowException() {
 A a = mock(A.class);
 Mockito.doThrow(new Exception("exception")).when(a).foo();
 Mockito.verify(a).foo();
 }

 @Test
 public void testInOrder() {
 {
 List singleMock = mock(List.class);
 singleMock.add("was added first");
 singleMock.add("was added second");
 InOrder inOrder = Mockito.inOrder(singleMock);
 inOrder.verify(singleMock).add("was added first");
 inOrder.verify(singleMock).add("was added second");
 }
 {
 List firstMock = mock(List.class);
 List secondMock = mock(List.class);
 firstMock.add("was called first");
 secondMock.add("was called second");
 InOrder inOrder = Mockito.inOrder(firstMock, secondMock);
 inOrder.verify(firstMock).add("was called first");
 inOrder.verify(secondMock).add("was called second");
 }
 }

 @Test
 public void testAnswer() {
 A a = mock(A.class);
 Mockito.doAnswer(new Answer<Void>() {
 public Void answer(InvocationOnMock invocation) {
 Object[] args = invocation.getArguments();
 Object mock = invocation.getMock();
 return null;
 }
 }).when(a).foo();
 a.foo();
 Mockito.verify(a).foo();
 }

 @Test
 public void testArgumentCaptor() {
 A a = mock(A.class);
 ArgumentCaptor<String> argument = ArgumentCaptor.forClass(String.class);
 a.foo("abc");
 Mockito.verify(a).foo(argument.capture());
 Assert.assertEquals("abc", argument.getValue());
 }

@PowerMockIgnore({
 "org.mockito.*", "org.robolectric.*", "org.json.*", "owo.com.androidunittest.targets.A"
})
@PrepareForTest({A.class})
public class PowerMockTest {
 @Rule
 public PowerMockRule rule = new PowerMockRule();
 @Test
 public void testStaticMethod() {
 PowerMockito.mockStatic(A.class);
 PowerMockito.when(A.publicStaticMethod()).thenReturn("abc");
 Assert.assertEquals("abc", A.publicStaticMethod());
 PowerMockito.verifyStatic();
 A.publicStaticMethod();
 }
 @Test
 public void testPrivateMethod() throws Exception {
 PowerMockito.spy(A.class);
 PowerMockito.when(A.class, "privateStaticMethod").thenReturn("abc");
 String real = A.callPrivateStaticMethod();
 Assert.assertEquals("callabc", real);
 PowerMockito.verifyPrivate(A.class).invoke("privateStaticMethod");
 }
 @Test
 public void testConstructor() throws Exception {
 A a = new A();
 PowerMockito.whenNew(A.class).withNoArguments().thenReturn(a);
 A a2 = A.create();
 Assert.assertEquals(a, a2);
 PowerMockito.verifyNew(A.class).withNoArguments();
 }
}

@RunWith(RobolectricTestRunner.class)
@Config(manifest = "src/test/AndroidManifest.xml", sdk = 21,//
 constants = BuildConfig.class, resourceDir = "../test/res", assetDir = "assets")
public class RobolectricTest {
 @Test
 public void testIsTextEmpty() {
 Assert.assertTrue(AndroidTarget.isTextEmpty(""));
 Assert.assertFalse(AndroidTarget.isTextEmpty("abc"));
 }
 @Test
 public void testCreateView() {
 MainActivity activity = Robolectric.setupActivity(MainActivity.class);
 View v = AndroidTarget.makeView(activity);
 Assert.assertNotNull(v);
 }
}