Merge "Convert to Mockito: NativeDeviceTest"
diff --git a/javatests/com/android/tradefed/device/NativeDeviceTest.java b/javatests/com/android/tradefed/device/NativeDeviceTest.java
index a69890d..2d42d7b 100644
--- a/javatests/com/android/tradefed/device/NativeDeviceTest.java
+++ b/javatests/com/android/tradefed/device/NativeDeviceTest.java
@@ -24,6 +24,10 @@
import static org.junit.Assert.fail;
import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.doThrow;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
import com.android.ddmlib.AdbCommandRejectedException;
import com.android.ddmlib.FileListingService.FileEntry;
@@ -56,12 +60,14 @@
import com.android.tradefed.util.ProcessInfo;
import com.android.tradefed.util.StreamUtil;
-import org.easymock.EasyMock;
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
+import org.mockito.AdditionalAnswers;
+import org.mockito.Mock;
import org.mockito.Mockito;
+import org.mockito.MockitoAnnotations;
import java.io.File;
import java.io.IOException;
@@ -86,20 +92,18 @@
private static final String MOCK_DEVICE_SERIAL = "serial";
private static final String FAKE_NETWORK_SSID = "FakeNet";
- private static final String FAKE_NETWORK_PASSWORD ="FakePass";
+ private static final String FAKE_NETWORK_PASSWORD = "FakePass";
- private IDevice mMockIDevice;
+ @Mock IDevice mMockIDevice;
private TestableAndroidNativeDevice mTestDevice;
- private IDeviceRecovery mMockRecovery;
- private IDeviceStateMonitor mMockStateMonitor;
- private IRunUtil mMockRunUtil;
- private IWifiHelper mMockWifi;
- private IDeviceMonitor mMockDvcMonitor;
+ @Mock IDeviceRecovery mMockRecovery;
+ @Mock IDeviceStateMonitor mMockStateMonitor;
+ @Mock IRunUtil mMockRunUtil;
+ @Mock IWifiHelper mMockWifi;
+ @Mock IDeviceMonitor mMockDvcMonitor;
private IHostOptions mHostOptions;
- /**
- * A {@link TestDevice} that is suitable for running tests against
- */
+ /** A {@link TestDevice} that is suitable for running tests against */
private class TestableAndroidNativeDevice extends NativeDevice {
public boolean wasCalled = false;
@@ -126,34 +130,30 @@
@Before
public void setUp() throws Exception {
+ MockitoAnnotations.initMocks(this);
+
mHostOptions = new HostOptions();
- mMockIDevice = EasyMock.createMock(IDevice.class);
- EasyMock.expect(mMockIDevice.getSerialNumber()).andReturn(MOCK_DEVICE_SERIAL).anyTimes();
- mMockRecovery = EasyMock.createMock(IDeviceRecovery.class);
- mMockStateMonitor = EasyMock.createMock(IDeviceStateMonitor.class);
- mMockDvcMonitor = EasyMock.createMock(IDeviceMonitor.class);
- mMockRunUtil = EasyMock.createMock(IRunUtil.class);
- mMockWifi = EasyMock.createMock(IWifiHelper.class);
- mMockWifi.cleanUp();
- EasyMock.expectLastCall().anyTimes();
+
+ when(mMockIDevice.getSerialNumber()).thenReturn(MOCK_DEVICE_SERIAL);
// A TestDevice with a no-op recoverDevice() implementation
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public void recoverDevice() throws DeviceNotAvailableException {
- // ignore
- }
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public void recoverDevice() throws DeviceNotAvailableException {
+ // ignore
+ }
- @Override
- public IDevice getIDevice() {
- return mMockIDevice;
- }
+ @Override
+ public IDevice getIDevice() {
+ return mMockIDevice;
+ }
- @Override
- IWifiHelper createWifiHelper() {
- return mMockWifi;
- }
- };
+ @Override
+ IWifiHelper createWifiHelper() {
+ return mMockWifi;
+ }
+ };
mTestDevice.setRecovery(mMockRecovery);
mTestDevice.setCommandTimeout(100);
mTestDevice.setLogStartDelay(-1);
@@ -281,13 +281,14 @@
/** Unit test for {@link NativeDevice#pushDir(File, String)}. */
@Test
public void testPushDir_childFile() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean pushFile(File localFile, String remoteFilePath)
- throws DeviceNotAvailableException {
- return true;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean pushFile(File localFile, String remoteFilePath)
+ throws DeviceNotAvailableException {
+ return true;
+ }
+ };
File testDir = FileUtil.createTempDir("pushDirTest");
FileUtil.createTempFile("test1", ".txt", testDir);
assertTrue(mTestDevice.pushDir(testDir, ""));
@@ -297,17 +298,20 @@
/** Unit test for {@link NativeDevice#pushDir(File, String)}. */
@Test
public void testPushDir_childDir() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String executeShellCommand(String cmd) throws DeviceNotAvailableException {
- return "";
- }
- @Override
- public boolean pushFile(File localFile, String remoteFilePath)
- throws DeviceNotAvailableException {
- return false;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String executeShellCommand(String cmd)
+ throws DeviceNotAvailableException {
+ return "";
+ }
+
+ @Override
+ public boolean pushFile(File localFile, String remoteFilePath)
+ throws DeviceNotAvailableException {
+ return false;
+ }
+ };
File testDir = FileUtil.createTempDir("pushDirTest");
File subDir = FileUtil.createTempDir("testSubDir", testDir);
FileUtil.createTempDir("test1", subDir);
@@ -350,7 +354,7 @@
/** Test {@link NativeDevice#pullDir(String, File)} when the remote directory is empty. */
@Test
public void testPullDir_nothingToDo() throws Exception {
- final IFileEntry fakeEntry = EasyMock.createMock(IFileEntry.class);
+ final IFileEntry fakeEntry = mock(IFileEntry.class);
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -367,9 +371,9 @@
};
File dir = FileUtil.createTempDir("tf-test");
Collection<IFileEntry> childrens = new ArrayList<>();
- EasyMock.expect(fakeEntry.getChildren(false)).andReturn(childrens);
+ when(fakeEntry.getChildren(false)).thenReturn(childrens);
// Empty list of childen
- EasyMock.replay(fakeEntry);
+
try {
boolean res = mTestDevice.pullDir("/some_device_path/screenshots/", dir);
assertTrue(res);
@@ -377,7 +381,6 @@
} finally {
FileUtil.recursiveDelete(dir);
}
- EasyMock.verify(fakeEntry);
}
/**
@@ -386,8 +389,8 @@
*/
@Test
public void testPullDir() throws Exception {
- final IFileEntry fakeEntry = EasyMock.createMock(IFileEntry.class);
- final IFileEntry fakeDir = EasyMock.createMock(IFileEntry.class);
+ final IFileEntry fakeEntry = mock(IFileEntry.class);
+ final IFileEntry fakeDir = mock(IFileEntry.class);
mTestDevice =
new TestableAndroidNativeDevice() {
private boolean mFirstCall = true;
@@ -423,22 +426,21 @@
};
File dir = FileUtil.createTempDir("tf-test");
Collection<IFileEntry> children = new ArrayList<>();
- IFileEntry fakeFile = EasyMock.createMock(IFileEntry.class);
+ IFileEntry fakeFile = mock(IFileEntry.class);
children.add(fakeFile);
- EasyMock.expect(fakeFile.isDirectory()).andReturn(false);
- EasyMock.expect(fakeFile.getName()).andReturn("fakeFile");
- EasyMock.expect(fakeFile.getFullPath()).andReturn("/some_device_path/fakeFile");
+ when(fakeFile.isDirectory()).thenReturn(false);
+ when(fakeFile.getName()).thenReturn("fakeFile");
+ when(fakeFile.getFullPath()).thenReturn("/some_device_path/fakeFile");
children.add(fakeDir);
- EasyMock.expect(fakeDir.isDirectory()).andReturn(true);
- EasyMock.expect(fakeDir.getName()).andReturn("fakeDir");
- EasyMock.expect(fakeDir.getFullPath()).andReturn("/some_device_path/fakeDir");
+ when(fakeDir.isDirectory()).thenReturn(true);
+ when(fakeDir.getName()).thenReturn("fakeDir");
+ when(fakeDir.getFullPath()).thenReturn("/some_device_path/fakeDir");
// #pullDir is being called on dir fakeDir to pull everything recursively.
Collection<IFileEntry> fakeDirChildren = new ArrayList<>();
- EasyMock.expect(fakeDir.getChildren(false)).andReturn(fakeDirChildren);
- EasyMock.expect(fakeEntry.getChildren(false)).andReturn(children);
+ when(fakeDir.getChildren(false)).thenReturn(fakeDirChildren);
+ when(fakeEntry.getChildren(false)).thenReturn(children);
- EasyMock.replay(fakeEntry, fakeFile, fakeDir);
try {
boolean res = mTestDevice.pullDir("/some_device_path/", dir);
assertTrue(res);
@@ -448,14 +450,13 @@
} finally {
FileUtil.recursiveDelete(dir);
}
- EasyMock.verify(fakeEntry, fakeFile, fakeDir);
}
/** Test pulling a directory when one of the pull fails. */
@Test
public void testPullDir_pullFail() throws Exception {
- final IFileEntry fakeEntry = EasyMock.createMock(IFileEntry.class);
- final IFileEntry fakeDir = EasyMock.createMock(IFileEntry.class);
+ final IFileEntry fakeEntry = mock(IFileEntry.class);
+ final IFileEntry fakeDir = mock(IFileEntry.class);
mTestDevice =
new TestableAndroidNativeDevice() {
private boolean mFirstCall = true;
@@ -497,29 +498,28 @@
};
File dir = FileUtil.createTempDir("tf-test");
Collection<IFileEntry> children = new ArrayList<>();
- IFileEntry fakeFile = EasyMock.createMock(IFileEntry.class);
+ IFileEntry fakeFile = mock(IFileEntry.class);
children.add(fakeFile);
- EasyMock.expect(fakeFile.isDirectory()).andReturn(false);
- EasyMock.expect(fakeFile.getName()).andReturn("fakeFile");
- EasyMock.expect(fakeFile.getFullPath()).andReturn("/some_device_path/fakeFile");
+ when(fakeFile.isDirectory()).thenReturn(false);
+ when(fakeFile.getName()).thenReturn("fakeFile");
+ when(fakeFile.getFullPath()).thenReturn("/some_device_path/fakeFile");
children.add(fakeDir);
- EasyMock.expect(fakeDir.isDirectory()).andReturn(true);
- EasyMock.expect(fakeDir.getName()).andReturn("fakeDir");
- EasyMock.expect(fakeDir.getFullPath()).andReturn("/some_device_path/fakeDir");
+ when(fakeDir.isDirectory()).thenReturn(true);
+ when(fakeDir.getName()).thenReturn("fakeDir");
+ when(fakeDir.getFullPath()).thenReturn("/some_device_path/fakeDir");
// #pullDir is being called on dir fakeDir to pull everything recursively.
Collection<IFileEntry> fakeDirChildren = new ArrayList<>();
- IFileEntry secondLevelChildren = EasyMock.createMock(IFileEntry.class);
+ IFileEntry secondLevelChildren = mock(IFileEntry.class);
fakeDirChildren.add(secondLevelChildren);
- EasyMock.expect(fakeDir.getChildren(false)).andReturn(fakeDirChildren);
- EasyMock.expect(fakeEntry.getChildren(false)).andReturn(children);
+ when(fakeDir.getChildren(false)).thenReturn(fakeDirChildren);
+ when(fakeEntry.getChildren(false)).thenReturn(children);
- EasyMock.expect(secondLevelChildren.isDirectory()).andReturn(false);
- EasyMock.expect(secondLevelChildren.getName()).andReturn("secondLevelChildren");
- EasyMock.expect(secondLevelChildren.getFullPath())
- .andReturn("/some_device_path/fakeDir/secondLevelChildren");
+ when(secondLevelChildren.isDirectory()).thenReturn(false);
+ when(secondLevelChildren.getName()).thenReturn("secondLevelChildren");
+ when(secondLevelChildren.getFullPath())
+ .thenReturn("/some_device_path/fakeDir/secondLevelChildren");
- EasyMock.replay(fakeEntry, fakeFile, fakeDir, secondLevelChildren);
try {
boolean res = mTestDevice.pullDir("/some_device_path/", dir);
// If one of the pull fails, the full command is considered failed.
@@ -533,7 +533,6 @@
} finally {
FileUtil.recursiveDelete(dir);
}
- EasyMock.verify(fakeEntry, fakeFile, fakeDir, secondLevelChildren);
}
/**
@@ -606,7 +605,7 @@
@Test
public void testSwitchUserTimeout_exception() throws Exception {
try {
- mTestDevice.switchUser(10, 5*1000);
+ mTestDevice.switchUser(10, 5 * 1000);
} catch (UnsupportedOperationException onse) {
return;
}
@@ -749,26 +748,27 @@
@Test
public void testConnectToWifiNetworkIfNeeded_alreadyConnected()
throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
- .andReturn(true);
- EasyMock.replay(mMockWifi);
- assertTrue(mTestDevice.connectToWifiNetworkIfNeeded(FAKE_NETWORK_SSID,
- FAKE_NETWORK_PASSWORD));
- EasyMock.verify(mMockWifi);
+ when(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
+ .thenReturn(true);
+
+ assertTrue(
+ mTestDevice.connectToWifiNetworkIfNeeded(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD));
}
/** Unit test for {@link NativeDevice#connectToWifiNetwork(String, String)}. */
@Test
public void testConnectToWifiNetwork_success() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.connectToNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD,
- mTestDevice.getOptions().getConnCheckUrl(), false)).andReturn(true);
+ when(mMockWifi.connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ false))
+ .thenReturn(true);
Map<String, String> fakeWifiInfo = new HashMap<String, String>();
fakeWifiInfo.put("bssid", FAKE_NETWORK_SSID);
- EasyMock.expect(mMockWifi.getWifiInfo()).andReturn(fakeWifiInfo);
- EasyMock.replay(mMockWifi, mMockIDevice);
- assertTrue(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID,
- FAKE_NETWORK_PASSWORD));
- EasyMock.verify(mMockWifi, mMockIDevice);
+ when(mMockWifi.getWifiInfo()).thenReturn(fakeWifiInfo);
+
+ assertTrue(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD));
}
/**
@@ -777,19 +777,26 @@
*/
@Test
public void testConnectToWifiNetwork_failure() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.connectToNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD,
- mTestDevice.getOptions().getConnCheckUrl(), false)).andReturn(false)
- .times(mTestDevice.getOptions().getWifiAttempts());
+ when(mMockWifi.connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ false))
+ .thenReturn(false);
Map<String, String> fakeWifiInfo = new HashMap<String, String>();
fakeWifiInfo.put("bssid", FAKE_NETWORK_SSID);
- EasyMock.expect(mMockWifi.getWifiInfo()).andReturn(fakeWifiInfo)
- .times(mTestDevice.getOptions().getWifiAttempts());
- mMockRunUtil.sleep(EasyMock.anyLong());
- EasyMock.expectLastCall().times(mTestDevice.getOptions().getWifiAttempts() - 1);
- EasyMock.replay(mMockWifi, mMockIDevice, mMockRunUtil);
- assertFalse(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID,
- FAKE_NETWORK_PASSWORD));
- EasyMock.verify(mMockWifi, mMockIDevice, mMockRunUtil);
+ when(mMockWifi.getWifiInfo()).thenReturn(fakeWifiInfo);
+
+ assertFalse(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD));
+ verify(mMockRunUtil, times(mTestDevice.getOptions().getWifiAttempts() - 1))
+ .sleep(Mockito.anyLong());
+ verify(mMockWifi, times(mTestDevice.getOptions().getWifiAttempts()))
+ .connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ false);
+ verify(mMockWifi, times(mTestDevice.getOptions().getWifiAttempts())).getWifiInfo();
}
/**
@@ -803,69 +810,72 @@
deviceOptionSetter.setOptionValue("max-wifi-connect-time", "10000");
Clock mockClock = Mockito.mock(Clock.class);
mTestDevice.setClock(mockClock);
- EasyMock.expect(
- mMockWifi.connectToNetwork(
- FAKE_NETWORK_SSID,
- FAKE_NETWORK_PASSWORD,
- mTestDevice.getOptions().getConnCheckUrl(),
- false))
- .andReturn(false)
- .times(2);
+ when(mMockWifi.connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ false))
+ .thenReturn(false);
Mockito.when(mockClock.millis())
.thenReturn(Long.valueOf(0), Long.valueOf(6000), Long.valueOf(12000));
Map<String, String> fakeWifiInfo = new HashMap<String, String>();
fakeWifiInfo.put("bssid", FAKE_NETWORK_SSID);
- EasyMock.expect(mMockWifi.getWifiInfo()).andReturn(fakeWifiInfo).times(2);
+ when(mMockWifi.getWifiInfo()).thenReturn(fakeWifiInfo);
- EasyMock.replay(mMockWifi, mMockIDevice);
assertFalse(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD));
- EasyMock.verify(mMockWifi, mMockIDevice);
+ verify(mMockWifi, times(2))
+ .connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ false);
+ verify(mMockWifi, times(2)).getWifiInfo();
Mockito.verify(mockClock, Mockito.times(3)).millis();
}
/** Unit test for {@link NativeDevice#connectToWifiNetwork(String, String, boolean)}. */
@Test
public void testConnectToWifiNetwork_scanSsid() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.connectToNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD,
- mTestDevice.getOptions().getConnCheckUrl(), true)).andReturn(true);
+ when(mMockWifi.connectToNetwork(
+ FAKE_NETWORK_SSID,
+ FAKE_NETWORK_PASSWORD,
+ mTestDevice.getOptions().getConnCheckUrl(),
+ true))
+ .thenReturn(true);
Map<String, String> fakeWifiInfo = new HashMap<String, String>();
fakeWifiInfo.put("bssid", FAKE_NETWORK_SSID);
- EasyMock.expect(mMockWifi.getWifiInfo()).andReturn(fakeWifiInfo);
- EasyMock.replay(mMockWifi, mMockIDevice);
- assertTrue(mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID,
- FAKE_NETWORK_PASSWORD, true));
- EasyMock.verify(mMockWifi, mMockIDevice);
+ when(mMockWifi.getWifiInfo()).thenReturn(fakeWifiInfo);
+
+ assertTrue(
+ mTestDevice.connectToWifiNetwork(FAKE_NETWORK_SSID, FAKE_NETWORK_PASSWORD, true));
}
/** Unit test for {@link NativeDevice#checkWifiConnection(String)}. */
@Test
public void testCheckWifiConnection() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.isWifiEnabled()).andReturn(true);
- EasyMock.expect(mMockWifi.getSSID()).andReturn("\"" + FAKE_NETWORK_SSID + "\"");
- EasyMock.expect(mMockWifi.hasValidIp()).andReturn(true);
- EasyMock.expect(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
- .andReturn(true);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.isWifiEnabled()).thenReturn(true);
+ when(mMockWifi.getSSID()).thenReturn("\"" + FAKE_NETWORK_SSID + "\"");
+ when(mMockWifi.hasValidIp()).thenReturn(true);
+ when(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
+ .thenReturn(true);
+
assertTrue(mTestDevice.checkWifiConnection(FAKE_NETWORK_SSID));
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#checkWifiConnection(String)} for a failure. */
@Test
public void testCheckWifiConnection_failure() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.isWifiEnabled()).andReturn(false);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.isWifiEnabled()).thenReturn(false);
+
assertFalse(mTestDevice.checkWifiConnection(FAKE_NETWORK_SSID));
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#isWifiEnabled()}. */
@Test
public void testIsWifiEnabled() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.isWifiEnabled()).andReturn(true);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.isWifiEnabled()).thenReturn(true);
+
assertTrue(mTestDevice.isWifiEnabled());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/**
@@ -873,41 +883,39 @@
*/
@Test
public void testIsWifiEnabled_exception() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.isWifiEnabled()).andThrow(new RuntimeException());
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.isWifiEnabled()).thenThrow(new RuntimeException());
+
assertFalse(mTestDevice.isWifiEnabled());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#disconnectFromWifi()}. */
@Test
public void testDisconnectFromWifi() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.disconnectFromNetwork()).andReturn(true);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.disconnectFromNetwork()).thenReturn(true);
+
assertTrue(mTestDevice.disconnectFromWifi());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#enableNetworkMonitor()}. */
@Test
public void testEnableNetworkMonitor() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.stopMonitor()).andReturn(null);
- EasyMock.expect(mMockWifi.startMonitor(EasyMock.anyLong(),
- EasyMock.eq(mTestDevice.getOptions().getConnCheckUrl()))).andReturn(true);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.stopMonitor()).thenReturn(null);
+ when(mMockWifi.startMonitor(
+ Mockito.anyLong(), Mockito.eq(mTestDevice.getOptions().getConnCheckUrl())))
+ .thenReturn(true);
+
assertTrue(mTestDevice.enableNetworkMonitor());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#enableNetworkMonitor()} in case of failure. */
@Test
public void testEnableNetworkMonitor_failure() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.stopMonitor()).andReturn(null);
- EasyMock.expect(mMockWifi.startMonitor(EasyMock.anyLong(),
- EasyMock.eq(mTestDevice.getOptions().getConnCheckUrl()))).andReturn(false);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.stopMonitor()).thenReturn(null);
+ when(mMockWifi.startMonitor(
+ Mockito.anyLong(), Mockito.eq(mTestDevice.getOptions().getConnCheckUrl())))
+ .thenReturn(false);
+
assertFalse(mTestDevice.enableNetworkMonitor());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#disableNetworkMonitor()}. */
@@ -917,62 +925,61 @@
samples.add(Long.valueOf(42));
samples.add(Long.valueOf(256));
samples.add(Long.valueOf(-1)); // failure to connect
- EasyMock.expect(mMockWifi.stopMonitor()).andReturn(samples);
- EasyMock.replay(mMockWifi, mMockIDevice);
+ when(mMockWifi.stopMonitor()).thenReturn(samples);
+
assertTrue(mTestDevice.disableNetworkMonitor());
- EasyMock.verify(mMockWifi, mMockIDevice);
}
/** Unit test for {@link NativeDevice#reconnectToWifiNetwork()}. */
@Test
public void testReconnectToWifiNetwork() throws DeviceNotAvailableException {
- EasyMock.expect(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
- .andReturn(false);
- EasyMock.expect(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
- .andReturn(true);
- mMockRunUtil.sleep(EasyMock.anyLong());
- EasyMock.expectLastCall();
- EasyMock.replay(mMockWifi, mMockIDevice, mMockRunUtil);
+ when(mMockWifi.checkConnectivity(mTestDevice.getOptions().getConnCheckUrl()))
+ .thenReturn(false, true);
+
try {
mTestDevice.reconnectToWifiNetwork();
} finally {
- EasyMock.verify(mMockWifi, mMockIDevice, mMockRunUtil);
+ verify(mMockRunUtil, times(1)).sleep(Mockito.anyLong());
}
}
/** Unit test for {@link NativeDevice#isHeadless()}. */
@Test
public void testIsHeadless() throws DeviceNotAvailableException {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return "1\n";
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return "1\n";
+ }
+ };
assertTrue(mTestDevice.isHeadless());
}
/** Unit test for {@link NativeDevice#isHeadless()}. */
@Test
public void testIsHeadless_notHeadless() throws DeviceNotAvailableException {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return null;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return null;
+ }
+ };
assertFalse(mTestDevice.isHeadless());
}
/** Unit test for {@link NativeDevice#getDeviceDate()}. */
@Test
public void testGetDeviceDate() throws DeviceNotAvailableException {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String executeShellCommand(String name) throws DeviceNotAvailableException {
- return "21692641\n";
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String executeShellCommand(String name)
+ throws DeviceNotAvailableException {
+ return "21692641\n";
+ }
+ };
assertEquals(21692641000L, mTestDevice.getDeviceDate());
}
@@ -993,11 +1000,11 @@
return 24;
}
};
- ITestLogger listener = EasyMock.createMock(ITestLogger.class);
- listener.testLog(dataName, LogDataType.BUGREPORTZ, stream);
- EasyMock.replay(listener);
+ ITestLogger listener = mock(ITestLogger.class);
+
assertTrue(mTestDevice.logBugreport(dataName, listener));
- EasyMock.verify(listener);
+
+ verify(listener).testLog(dataName, LogDataType.BUGREPORTZ, stream);
}
/** Unit test for {@link NativeDevice#logBugreport(String, ITestLogger)}. */
@@ -1024,11 +1031,11 @@
return 23;
}
};
- ITestLogger listener = EasyMock.createMock(ITestLogger.class);
- listener.testLog(dataName, LogDataType.BUGREPORT, stream);
- EasyMock.replay(listener);
+ ITestLogger listener = mock(ITestLogger.class);
+
assertTrue(mTestDevice.logBugreport(dataName, listener));
- EasyMock.verify(listener);
+
+ verify(listener).testLog(dataName, LogDataType.BUGREPORT, stream);
}
/** Unit test for {@link NativeDevice#logBugreport(String, ITestLogger)}. */
@@ -1051,10 +1058,9 @@
return 23;
}
};
- ITestLogger listener = EasyMock.createMock(ITestLogger.class);
- EasyMock.replay(listener);
+ ITestLogger listener = mock(ITestLogger.class);
+
assertFalse(mTestDevice.logBugreport("test", listener));
- EasyMock.verify(listener);
}
/** Unit test for {@link NativeDevice#takeBugreport()}. */
@@ -1074,12 +1080,13 @@
/** Unit test for {@link NativeDevice#takeBugreport()}. */
@Test
public void testTakeBugreport_oldDevice() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public int getApiLevel() throws DeviceNotAvailableException {
- return 19;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public int getApiLevel() throws DeviceNotAvailableException {
+ return 19;
+ }
+ };
Bugreport report = mTestDevice.takeBugreport();
try {
assertNotNull(report);
@@ -1093,20 +1100,22 @@
/** Unit test for {@link NativeDevice#takeBugreport()}. */
@Test
public void testTakeBugreport() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public int getApiLevel() throws DeviceNotAvailableException {
- return 24;
- }
- @Override
- protected File getBugreportzInternal() {
- try {
- return FileUtil.createTempFile("bugreportz", ".zip");
- } catch (IOException e) {
- return null;
- }
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public int getApiLevel() throws DeviceNotAvailableException {
+ return 24;
+ }
+
+ @Override
+ protected File getBugreportzInternal() {
+ try {
+ return FileUtil.createTempFile("bugreportz", ".zip");
+ } catch (IOException e) {
+ return null;
+ }
+ }
+ };
Bugreport report = mTestDevice.takeBugreport();
try {
assertNotNull(report);
@@ -1119,39 +1128,48 @@
/** Unit test for {@link NativeDevice#getDeviceDate()}. */
@Test
public void testGetDeviceDate_wrongformat() throws DeviceNotAvailableException {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String executeShellCommand(String name) throws DeviceNotAvailableException {
- return "WRONG\n";
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String executeShellCommand(String name)
+ throws DeviceNotAvailableException {
+ return "WRONG\n";
+ }
+ };
assertEquals(0, mTestDevice.getDeviceDate());
}
@Test
public void testGetBugreport_deviceUnavail() throws Exception {
final String expectedOutput = "this is the output\r\n in two lines\r\n";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public void executeShellCommand(
- String command, IShellOutputReceiver receiver,
- long maxTimeToOutputShellResponse, TimeUnit timeUnit, int retryAttempts)
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public void executeShellCommand(
+ String command,
+ IShellOutputReceiver receiver,
+ long maxTimeToOutputShellResponse,
+ TimeUnit timeUnit,
+ int retryAttempts)
throws DeviceNotAvailableException {
- String fakeRep = expectedOutput;
- receiver.addOutput(fakeRep.getBytes(), 0, fakeRep.getBytes().length);
- }
- @Override
- public int getApiLevel() throws DeviceNotAvailableException {
- return 22;
- }
- };
+ String fakeRep = expectedOutput;
+ receiver.addOutput(fakeRep.getBytes(), 0, fakeRep.getBytes().length);
+ }
+
+ @Override
+ public int getApiLevel() throws DeviceNotAvailableException {
+ return 22;
+ }
+ };
// FIXME: this isn't actually causing a DeviceNotAvailableException to be thrown
- mMockRecovery.recoverDevice(EasyMock.eq(mMockStateMonitor), EasyMock.eq(false));
- EasyMock.expectLastCall().andThrow(new DeviceNotAvailableException("test", "serial"));
- EasyMock.replay(mMockRecovery, mMockIDevice);
- assertEquals(expectedOutput, StreamUtil.getStringFromStream(
- mTestDevice.getBugreport().createInputStream()));
+ doThrow(new DeviceNotAvailableException("test", "serial"))
+ .when(mMockRecovery)
+ .recoverDevice(Mockito.eq(mMockStateMonitor), Mockito.eq(false));
+
+ assertEquals(
+ expectedOutput,
+ StreamUtil.getStringFromStream(mTestDevice.getBugreport().createInputStream()));
}
@Test
@@ -1179,14 +1197,13 @@
return null;
}
};
- EasyMock.replay(mMockRecovery, mMockIDevice);
+
assertEquals(0, mTestDevice.getBugreport().size());
- EasyMock.verify(mMockRecovery, mMockIDevice);
}
@Test
public void testGetBugreport_deviceUnavail_fallback() throws Exception {
- final IFileEntry fakeEntry = EasyMock.createMock(IFileEntry.class);
+ final IFileEntry fakeEntry = mock(IFileEntry.class);
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -1221,14 +1238,13 @@
};
List<IFileEntry> list = new ArrayList<>();
list.add(fakeEntry);
- EasyMock.expect(fakeEntry.getChildren(false)).andReturn(list);
- EasyMock.expect(fakeEntry.getName()).andReturn("bugreport-NYC-2016-08-17-10-17-00.tmp");
- EasyMock.replay(fakeEntry, mMockRecovery, mMockIDevice);
+ when(fakeEntry.getChildren(false)).thenReturn(list);
+ when(fakeEntry.getName()).thenReturn("bugreport-NYC-2016-08-17-10-17-00.tmp");
+
InputStreamSource res = null;
try {
res = mTestDevice.getBugreport();
assertNotNull(res);
- EasyMock.verify(fakeEntry, mMockRecovery, mMockIDevice);
} finally {
StreamUtil.cancel(res);
}
@@ -1322,7 +1338,7 @@
@Test
public void testGetBugreportz_fallBack_validation() throws Exception {
- IFileEntry entryMock = EasyMock.createMock(IFileEntry.class);
+ IFileEntry entryMock = mock(IFileEntry.class);
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -1350,11 +1366,11 @@
}
}
};
- IFileEntry childNode = EasyMock.createMock(IFileEntry.class);
- EasyMock.expect(entryMock.getChildren(false)).andReturn(Arrays.asList(childNode));
- EasyMock.expect(childNode.getName()).andReturn("bugreport-test-partial.zip");
+ IFileEntry childNode = mock(IFileEntry.class);
+ when(entryMock.getChildren(false)).thenReturn(Arrays.asList(childNode));
+ when(childNode.getName()).thenReturn("bugreport-test-partial.zip");
FileInputStreamSource f = null;
- EasyMock.replay(entryMock, childNode);
+
try {
f = (FileInputStreamSource) mTestDevice.getBugreportz();
assertNull(f);
@@ -1364,7 +1380,6 @@
f.cleanFile();
}
}
- EasyMock.verify(entryMock, childNode);
}
/**
@@ -1387,12 +1402,11 @@
File localFile = FileUtil.createTempFile("timezonetest", ".txt");
try {
localFile.setLastModified(1470906000000L); // Thu Aug 11 09:00:00 GMT 2016
- IFileEntry remoteFile = EasyMock.createMock(IFileEntry.class);
- EasyMock.expect(remoteFile.getDate()).andReturn("2016-08-11");
- EasyMock.expect(remoteFile.getTime()).andReturn("18:00");
- EasyMock.replay(remoteFile);
+ IFileEntry remoteFile = mock(IFileEntry.class);
+ when(remoteFile.getDate()).thenReturn("2016-08-11");
+ when(remoteFile.getTime()).thenReturn("18:00");
+
assertTrue(testDevice.isNewer(localFile, remoteFile));
- EasyMock.verify(remoteFile);
} finally {
FileUtil.deleteFile(localFile);
}
@@ -1419,13 +1433,12 @@
File localFile = FileUtil.createTempFile("timezonetest", ".txt");
try {
localFile.setLastModified(1470906000000L); // Thu, 11 Aug 2016 09:00:00 GMT
- IFileEntry remoteFile = EasyMock.createMock(IFileEntry.class);
- EasyMock.expect(remoteFile.getDate()).andReturn("2016-08-11");
- EasyMock.expect(remoteFile.getTime()).andReturn("18:15");
- EasyMock.replay(remoteFile);
+ IFileEntry remoteFile = mock(IFileEntry.class);
+ when(remoteFile.getDate()).thenReturn("2016-08-11");
+ when(remoteFile.getTime()).thenReturn("18:15");
+
// Should sync because after time offset correction, file is older.
assertTrue(testDevice.isNewer(localFile, remoteFile));
- EasyMock.verify(remoteFile);
} finally {
FileUtil.deleteFile(localFile);
}
@@ -1452,12 +1465,11 @@
File localFile = FileUtil.createTempFile("timezonetest", ".txt");
try {
localFile.setLastModified(1470906000000L); // Thu, 11 Aug 2016 09:00:00 GMT
- IFileEntry remoteFile = EasyMock.createMock(IFileEntry.class);
- EasyMock.expect(remoteFile.getDate()).andReturn("2016-08-11");
- EasyMock.expect(remoteFile.getTime()).andReturn("18:10");
- EasyMock.replay(remoteFile);
+ IFileEntry remoteFile = mock(IFileEntry.class);
+ when(remoteFile.getDate()).thenReturn("2016-08-11");
+ when(remoteFile.getTime()).thenReturn("18:10");
+
assertFalse(testDevice.isNewer(localFile, remoteFile));
- EasyMock.verify(remoteFile);
} finally {
FileUtil.deleteFile(localFile);
}
@@ -1467,12 +1479,13 @@
@Test
public void testGetBuildAlias() throws DeviceNotAvailableException {
final String alias = "alias\n";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return alias;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return alias;
+ }
+ };
assertEquals(alias, mTestDevice.getBuildAlias());
}
@@ -1481,16 +1494,18 @@
public void testGetBuildAlias_null() throws DeviceNotAvailableException {
final String alias = null;
final String buildId = "alias\n";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return alias;
- }
- @Override
- public String getBuildId() throws DeviceNotAvailableException {
- return buildId;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return alias;
+ }
+
+ @Override
+ public String getBuildId() throws DeviceNotAvailableException {
+ return buildId;
+ }
+ };
assertEquals(buildId, mTestDevice.getBuildAlias());
}
@@ -1499,16 +1514,18 @@
public void testGetBuildAlias_empty() throws DeviceNotAvailableException {
final String alias = "";
final String buildId = "alias\n";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return alias;
- }
- @Override
- public String getBuildId() throws DeviceNotAvailableException {
- return buildId;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return alias;
+ }
+
+ @Override
+ public String getBuildId() throws DeviceNotAvailableException {
+ return buildId;
+ }
+ };
assertEquals(buildId, mTestDevice.getBuildAlias());
}
@@ -1516,12 +1533,13 @@
@Test
public void testGetBuildId() throws DeviceNotAvailableException {
final String buildId = "299865";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return buildId;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return buildId;
+ }
+ };
assertEquals(buildId, mTestDevice.getBuildId());
}
@@ -1529,12 +1547,13 @@
@Test
public void testGetBuildId_null() throws DeviceNotAvailableException {
final String buildId = null;
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return buildId;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return buildId;
+ }
+ };
assertEquals(IBuildInfo.UNKNOWN_BUILD_ID, mTestDevice.getBuildId());
}
@@ -1542,12 +1561,13 @@
@Test
public void testGetBuildFlavor() throws DeviceNotAvailableException {
final String flavor = "ham-user";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- return flavor;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ return flavor;
+ }
+ };
assertEquals(flavor, mTestDevice.getBuildFlavor());
}
@@ -1557,20 +1577,21 @@
final String productName = "prod";
final String buildType = "buildtype";
String expected = String.format("%s-%s", productName, buildType);
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- if ("ro.build.flavor".equals(name)) {
- return null;
- } else if ("ro.product.name".equals(name)) {
- return productName;
- } else if ("ro.build.type".equals(name)) {
- return buildType;
- } else {
- return null;
- }
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ if ("ro.build.flavor".equals(name)) {
+ return null;
+ } else if ("ro.product.name".equals(name)) {
+ return productName;
+ } else if ("ro.build.type".equals(name)) {
+ return buildType;
+ } else {
+ return null;
+ }
+ }
+ };
assertEquals(expected, mTestDevice.getBuildFlavor());
}
@@ -1579,20 +1600,21 @@
public void testGetBuildFlavor_null() throws DeviceNotAvailableException {
final String productName = null;
final String buildType = "buildtype";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public String getProperty(String name) throws DeviceNotAvailableException {
- if ("ro.build.flavor".equals(name)) {
- return "";
- } else if ("ro.product.name".equals(name)) {
- return productName;
- } else if ("ro.build.type".equals(name)) {
- return buildType;
- } else {
- return null;
- }
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public String getProperty(String name) throws DeviceNotAvailableException {
+ if ("ro.build.flavor".equals(name)) {
+ return "";
+ } else if ("ro.product.name".equals(name)) {
+ return productName;
+ } else if ("ro.build.type".equals(name)) {
+ return buildType;
+ } else {
+ return null;
+ }
+ }
+ };
assertNull(mTestDevice.getBuildFlavor());
}
@@ -1600,72 +1622,69 @@
@Test
public void testDoAdbReboot_emulator() throws Exception {
final String into = "bootloader";
- mMockIDevice.reboot(into);
- EasyMock.expectLastCall();
- EasyMock.replay(mMockIDevice);
+
mTestDevice.doAdbReboot(RebootMode.REBOOT_INTO_BOOTLOADER, "");
- EasyMock.verify(mMockIDevice);
+ verify(mMockIDevice, times(1)).reboot(into);
}
/** Unit test for {@link NativeDevice#doReboot(RebootMode, String)} ()}. */
@Test
public void testDoReboot() throws Exception {
- NativeDevice testDevice = new NativeDevice(mMockIDevice,
- mMockStateMonitor, mMockDvcMonitor) {
- @Override
- public TestDeviceState getDeviceState() {
- return TestDeviceState.ONLINE;
- }
- };
- mMockIDevice.reboot(null);
- EasyMock.expectLastCall();
- EasyMock.expect(mMockStateMonitor.waitForDeviceNotAvailable(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ NativeDevice testDevice =
+ new NativeDevice(mMockIDevice, mMockStateMonitor, mMockDvcMonitor) {
+ @Override
+ public TestDeviceState getDeviceState() {
+ return TestDeviceState.ONLINE;
+ }
+ };
+
+ when(mMockStateMonitor.waitForDeviceNotAvailable(Mockito.anyLong())).thenReturn(true);
+
testDevice.doReboot(RebootMode.REBOOT_FULL, null);
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ verify(mMockIDevice, times(1)).reboot(null);
}
/** Unit test for {@link NativeDevice#doReboot(RebootMode, String)} ()}. */
@Test
public void testDoReboot_skipped() throws Exception {
- NativeDevice testDevice = new NativeDevice(mMockIDevice,
- mMockStateMonitor, mMockDvcMonitor) {
- @Override
- public TestDeviceState getDeviceState() {
- mOptions = new TestDeviceOptions() {
+ NativeDevice testDevice =
+ new NativeDevice(mMockIDevice, mMockStateMonitor, mMockDvcMonitor) {
@Override
- public boolean shouldDisableReboot() {
- return true;
+ public TestDeviceState getDeviceState() {
+ mOptions =
+ new TestDeviceOptions() {
+ @Override
+ public boolean shouldDisableReboot() {
+ return true;
+ }
+ };
+ return TestDeviceState.ONLINE;
}
};
- return TestDeviceState.ONLINE;
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
testDevice.doReboot(RebootMode.REBOOT_FULL, null);
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#doReboot(RebootMode, String)} ()}. */
@Test
public void testDoReboot_fastboot() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public TestDeviceState getDeviceState() {
- return TestDeviceState.FASTBOOT;
- }
- @Override
- public CommandResult executeFastbootCommand(String... cmdArgs)
- throws DeviceNotAvailableException, UnsupportedOperationException {
- wasCalled = true;
- return new CommandResult();
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public TestDeviceState getDeviceState() {
+ return TestDeviceState.FASTBOOT;
+ }
+
+ @Override
+ public CommandResult executeFastbootCommand(String... cmdArgs)
+ throws DeviceNotAvailableException, UnsupportedOperationException {
+ wasCalled = true;
+ return new CommandResult();
+ }
+ };
+
mTestDevice.doReboot(RebootMode.REBOOT_FULL, null);
assertTrue(mTestDevice.wasCalled);
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#rebootIntoSideload()}}. */
@@ -1679,13 +1698,11 @@
}
};
String into = "sideload";
- mMockIDevice.reboot(into);
- EasyMock.expectLastCall();
- EasyMock.expect(mMockStateMonitor.waitForDeviceInSideload(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ when(mMockStateMonitor.waitForDeviceInSideload(Mockito.anyLong())).thenReturn(true);
+
testDevice.rebootIntoSideload();
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ verify(mMockIDevice, times(1)).reboot(into);
}
/** Unit test for {@link NativeDevice#rebootIntoBootloader()}}. */
@@ -1704,14 +1721,12 @@
}
};
String into = "bootloader";
- mMockIDevice.reboot(into);
- EasyMock.expectLastCall();
- mMockStateMonitor.setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
- EasyMock.expect(mMockStateMonitor.waitForDeviceBootloader(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ when(mMockStateMonitor.waitForDeviceBootloader(Mockito.anyLong())).thenReturn(true);
+
testDevice.rebootIntoBootloader();
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ verify(mMockIDevice, times(1)).reboot(into);
+ verify(mMockStateMonitor).setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
}
/**
@@ -1741,13 +1756,13 @@
return MOCK_DEVICE_SERIAL;
}
};
- mMockStateMonitor.setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
- EasyMock.expect(mMockStateMonitor.waitForDeviceBootloader(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ when(mMockStateMonitor.waitForDeviceBootloader(Mockito.anyLong())).thenReturn(true);
+
testDevice.rebootIntoBootloader();
assertTrue(testDevice.wasCalled);
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ verify(mMockStateMonitor).setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
}
/** Unit test for {@link NativeDevice#rebootIntoFastbootd()}}. */
@@ -1766,14 +1781,12 @@
}
};
String into = "fastboot";
- mMockIDevice.reboot(into);
- EasyMock.expectLastCall();
- mMockStateMonitor.setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
- EasyMock.expect(mMockStateMonitor.waitForDeviceBootloader(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ when(mMockStateMonitor.waitForDeviceBootloader(Mockito.anyLong())).thenReturn(true);
+
testDevice.rebootIntoFastbootd();
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ verify(mMockIDevice, times(1)).reboot(into);
+ verify(mMockStateMonitor).setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
}
/**
@@ -1803,136 +1816,153 @@
return MOCK_DEVICE_SERIAL;
}
};
- mMockStateMonitor.setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
- EasyMock.expect(mMockStateMonitor.waitForDeviceBootloader(EasyMock.anyLong()))
- .andReturn(true);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ when(mMockStateMonitor.waitForDeviceBootloader(Mockito.anyLong())).thenReturn(true);
+
testDevice.rebootIntoFastbootd();
assertTrue(testDevice.wasCalled);
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+
+ verify(mMockStateMonitor).setFastbootSerialNumber(MOCK_DEVICE_SERIAL);
}
/** Unit test for {@link NativeDevice#unlockDevice()} already decrypted. */
@Test
public void testUnlockDevice_skipping() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean isEncryptionSupported() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
- return false;
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean isEncryptionSupported() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
+ return false;
+ }
+ };
+
assertTrue(mTestDevice.unlockDevice());
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#unlockDevice()}. */
@Test
public void testUnlockDevice() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean isEncryptionSupported() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean enableAdbRoot() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public String executeShellCommand(String command) throws DeviceNotAvailableException {
- return "200 checkpw -1";
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean isEncryptionSupported() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean enableAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public String executeShellCommand(String command)
+ throws DeviceNotAvailableException {
+ return "200 checkpw -1";
+ }
+ };
+
assertTrue(mTestDevice.unlockDevice());
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#unlockDevice()}. */
@Test
public void testUnlockDevice_garbageOutput() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean isEncryptionSupported() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean enableAdbRoot() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public String executeShellCommand(String command) throws DeviceNotAvailableException {
- return "gdsgdgggsgdg not working";
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean isEncryptionSupported() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean enableAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public String executeShellCommand(String command)
+ throws DeviceNotAvailableException {
+ return "gdsgdgggsgdg not working";
+ }
+ };
+
assertFalse(mTestDevice.unlockDevice());
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#unlockDevice()}. */
@Test
public void testUnlockDevice_emptyOutput() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean isEncryptionSupported() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean enableAdbRoot() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public String executeShellCommand(String command) throws DeviceNotAvailableException {
- return "";
- }
- };
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean isEncryptionSupported() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean enableAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public String executeShellCommand(String command)
+ throws DeviceNotAvailableException {
+ return "";
+ }
+ };
+
assertFalse(mTestDevice.unlockDevice());
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/** Unit test for {@link NativeDevice#unlockDevice()}. */
@Test
public void testUnlockDevice_goodOutputPasswordEnteredCorrectly() throws Exception {
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean isEncryptionSupported() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public boolean enableAdbRoot() throws DeviceNotAvailableException {
- return true;
- }
- @Override
- public String executeShellCommand(String command) throws DeviceNotAvailableException {
- return "200 encryption 0";
- }
- };
- EasyMock.expect(mMockStateMonitor.waitForDeviceAvailable()).andReturn(mMockIDevice);
- EasyMock.replay(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean isEncryptionSupported() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean isDeviceEncrypted() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public boolean enableAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+
+ @Override
+ public String executeShellCommand(String command)
+ throws DeviceNotAvailableException {
+ return "200 encryption 0";
+ }
+ };
+ when(mMockStateMonitor.waitForDeviceAvailable()).thenReturn(mMockIDevice);
+
assertTrue(mTestDevice.unlockDevice());
- EasyMock.verify(mMockIDevice, mMockStateMonitor, mMockDvcMonitor);
}
/**
@@ -1941,8 +1971,9 @@
*/
@Test
public void testParseDfOutput_mountWithNumber() {
- String dfOutput = "Filesystem 1K-blocks Used Available Use% Mounted on\n" +
- "/dev/fuse 31154688 100576 31054112 1% /storage/3134-3433";
+ String dfOutput =
+ "Filesystem 1K-blocks Used Available Use% Mounted on\n"
+ + "/dev/fuse 31154688 100576 31054112 1% /storage/3134-3433";
Long res = mTestDevice.parseFreeSpaceFromModernOutput(dfOutput);
assertNotNull(res);
assertEquals(31054112L, res.longValue());
@@ -1954,8 +1985,9 @@
*/
@Test
public void testParseDfOutput() {
- String dfOutput = "Filesystem 1K-blocks Used Available Use% Mounted on\n" +
- "/dev/fuse 31154688 100576 31054112 1% /storage/sdcard58";
+ String dfOutput =
+ "Filesystem 1K-blocks Used Available Use% Mounted on\n"
+ + "/dev/fuse 31154688 100576 31054112 1% /storage/sdcard58";
Long res = mTestDevice.parseFreeSpaceFromModernOutput(dfOutput);
assertNotNull(res);
assertEquals(31054112L, res.longValue());
@@ -1967,8 +1999,9 @@
*/
@Test
public void testParseDfOutput_wrongMount() {
- String dfOutput = "Filesystem 1K-blocks Used Available Use% Mounted on\n" +
- "/dev/fuse 31154688 100576 31054112 1% \test\\wrongpath";
+ String dfOutput =
+ "Filesystem 1K-blocks Used Available Use% Mounted on\n"
+ + "/dev/fuse 31154688 100576 31054112 1% \test\\wrongpath";
Long res = mTestDevice.parseFreeSpaceFromModernOutput(dfOutput);
assertNull(res);
}
@@ -1979,8 +2012,9 @@
*/
@Test
public void testParseDfOutput_filesystemWithNumber() {
- String dfOutput = "Filesystem 1K-blocks Used Available Use% Mounted on\n" +
- "/dev/dm-1 31154688 100576 31054112 1% /";
+ String dfOutput =
+ "Filesystem 1K-blocks Used Available Use% Mounted on\n"
+ + "/dev/dm-1 31154688 100576 31054112 1% /";
Long res = mTestDevice.parseFreeSpaceFromModernOutput(dfOutput);
assertNotNull(res);
assertEquals(31054112L, res.longValue());
@@ -2109,12 +2143,13 @@
@Test
public void testGetDeviceDescriptor() {
final String serial = "Test";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public IDevice getIDevice() {
- return new StubDevice(serial);
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public IDevice getIDevice() {
+ return new StubDevice(serial);
+ }
+ };
DeviceDescriptor desc = mTestDevice.getDeviceDescriptor();
assertTrue(desc.isStubDevice());
assertEquals(serial, desc.getSerial());
@@ -2129,12 +2164,12 @@
public void testPullFile() throws Exception {
final String fakeRemotePath = "/test/";
SyncService s = Mockito.mock(SyncService.class);
- EasyMock.expect(mMockIDevice.getSyncService()).andReturn(s);
- EasyMock.replay(mMockIDevice);
+ when(mMockIDevice.getSyncService()).thenReturn(s);
+
File tmpFile = FileUtil.createTempFile("pull", ".test");
try {
boolean res = mTestDevice.pullFile(fakeRemotePath, tmpFile);
- EasyMock.verify(mMockIDevice);
+
Mockito.verify(s)
.pullFile(
Mockito.eq(fakeRemotePath),
@@ -2155,8 +2190,8 @@
public void testPullFile_fails() throws Exception {
final String fakeRemotePath = "/test/";
SyncService s = Mockito.mock(SyncService.class);
- EasyMock.expect(mMockIDevice.getSyncService()).andReturn(s);
- EasyMock.replay(mMockIDevice);
+ when(mMockIDevice.getSyncService()).thenReturn(s);
+
File tmpFile = FileUtil.createTempFile("pull", ".test");
doThrow(new SyncException(SyncError.CANCELED))
.when(s)
@@ -2166,7 +2201,7 @@
Mockito.any(ISyncProgressMonitor.class));
try {
boolean res = mTestDevice.pullFile(fakeRemotePath, tmpFile);
- EasyMock.verify(mMockIDevice);
+
Mockito.verify(s)
.pullFile(
Mockito.eq(fakeRemotePath),
@@ -2185,13 +2220,14 @@
@Test
public void testPullFile_returnFileSuccess() throws Exception {
final String fakeRemotePath = "/test/";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean pullFile(String remoteFilePath, File localFile)
- throws DeviceNotAvailableException {
- return true;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean pullFile(String remoteFilePath, File localFile)
+ throws DeviceNotAvailableException {
+ return true;
+ }
+ };
File res = mTestDevice.pullFile(fakeRemotePath);
try {
assertNotNull(res);
@@ -2206,13 +2242,14 @@
@Test
public void testPullFile_returnNull() throws Exception {
final String fakeRemotePath = "/test/";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean pullFile(String remoteFilePath, File localFile)
- throws DeviceNotAvailableException {
- return false;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean pullFile(String remoteFilePath, File localFile)
+ throws DeviceNotAvailableException {
+ return false;
+ }
+ };
File res = mTestDevice.pullFile(fakeRemotePath);
try {
assertNull(res);
@@ -2228,13 +2265,14 @@
@Test
public void testPullFileContents_returnFileSuccess() throws Exception {
final String fakeRemotePath = "/test/";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean pullFile(String remoteFilePath, File localFile)
- throws DeviceNotAvailableException {
- return true;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean pullFile(String remoteFilePath, File localFile)
+ throws DeviceNotAvailableException {
+ return true;
+ }
+ };
String res = mTestDevice.pullFileContents(fakeRemotePath);
assertNotNull(res);
}
@@ -2246,13 +2284,14 @@
@Test
public void testPullFileContents_returnNull() throws Exception {
final String fakeRemotePath = "/test/";
- mTestDevice = new TestableAndroidNativeDevice() {
- @Override
- public boolean pullFile(String remoteFilePath, File localFile)
- throws DeviceNotAvailableException {
- return false;
- }
- };
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ public boolean pullFile(String remoteFilePath, File localFile)
+ throws DeviceNotAvailableException {
+ return false;
+ }
+ };
String res = mTestDevice.pullFileContents(fakeRemotePath);
assertNull(res);
}
@@ -2265,12 +2304,12 @@
public void testPushFile() throws Exception {
final String fakeRemotePath = "/test/";
SyncService s = Mockito.mock(SyncService.class);
- EasyMock.expect(mMockIDevice.getSyncService()).andReturn(s);
- EasyMock.replay(mMockIDevice);
+ when(mMockIDevice.getSyncService()).thenReturn(s);
+
File tmpFile = FileUtil.createTempFile("push", ".test");
try {
boolean res = mTestDevice.pushFile(tmpFile, fakeRemotePath);
- EasyMock.verify(mMockIDevice);
+
Mockito.verify(s)
.pushFile(
Mockito.eq(tmpFile.getAbsolutePath()),
@@ -2291,8 +2330,8 @@
public void testPushFile_fails() throws Exception {
final String fakeRemotePath = "/test/";
SyncService s = Mockito.mock(SyncService.class);
- EasyMock.expect(mMockIDevice.getSyncService()).andReturn(s);
- EasyMock.replay(mMockIDevice);
+ when(mMockIDevice.getSyncService()).thenReturn(s);
+
File tmpFile = FileUtil.createTempFile("push", ".test");
doThrow(new SyncException(SyncError.CANCELED))
.when(s)
@@ -2302,7 +2341,7 @@
Mockito.any(ISyncProgressMonitor.class));
try {
boolean res = mTestDevice.pushFile(tmpFile, fakeRemotePath);
- EasyMock.verify(mMockIDevice);
+
Mockito.verify(s)
.pushFile(
Mockito.eq(tmpFile.getAbsolutePath()),
@@ -2321,9 +2360,8 @@
final String fakePid = "914";
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn(fakePid).when(spy).executeShellCommand("pidof system_server");
- EasyMock.replay(mMockIDevice);
+
assertEquals(fakePid, spy.getProcessPid("system_server"));
- EasyMock.verify(mMockIDevice);
}
/** Test get Process pid by process name with adb shell return of extra new line */
@@ -2332,9 +2370,8 @@
final String fakePid = "914";
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn(fakePid + "\n").when(spy).executeShellCommand("pidof system_server");
- EasyMock.replay(mMockIDevice);
+
assertEquals(fakePid, spy.getProcessPid("system_server"));
- EasyMock.verify(mMockIDevice);
}
/** Test get Process pid return null with invalid shell command output */
@@ -2342,9 +2379,8 @@
public void testGetProcessPidInvalidOutput() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("invalid output").when(spy).executeShellCommand("pidof system_server");
- EasyMock.replay(mMockIDevice);
+
assertNull(spy.getProcessPid("system_server"));
- EasyMock.verify(mMockIDevice);
}
/** Test get Process pid return null with shell command empty output */
@@ -2352,9 +2388,8 @@
public void testGetProcessPidEmptyOutput() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("").when(spy).executeShellCommand("pidof system_server");
- EasyMock.replay(mMockIDevice);
+
assertNull(spy.getProcessPid("system_server"));
- EasyMock.verify(mMockIDevice);
}
/** Test get ProcessInfo by process name */
@@ -2367,12 +2402,11 @@
doReturn("12:07:32").when(spy).executeShellCommand("ps -p " + fakePid + " -o stime=");
doReturn(fakeCreationTime).when(spy).executeShellCommand("date -d\"12:07:32\" +%s");
doReturn("system").when(spy).executeShellCommand("stat -c%U /proc/" + fakePid);
- EasyMock.replay(mMockIDevice);
+
assertEquals(Integer.parseInt(fakePid), spy.getProcessByName("system_server").getPid());
assertEquals(
Long.parseLong(fakeCreationTime),
spy.getProcessByName("system_server").getStartTime());
- EasyMock.verify(mMockIDevice);
}
/** Test get ProcessInfo by process name return null for invalid process */
@@ -2380,9 +2414,8 @@
public void testGetProcessByNameInvalidProcess() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("").when(spy).executeShellCommand("pidof system_server");
- EasyMock.replay(mMockIDevice);
+
assertNull(spy.getProcessByName("system_server"));
- EasyMock.verify(mMockIDevice);
}
/** Test get ProcessInfo by process name return null for invalid process */
@@ -2391,93 +2424,83 @@
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("120").when(spy).executeShellCommand("pidof system_server");
doReturn("").when(spy).executeShellCommand("ps -p 120 -o stime=");
- EasyMock.replay(mMockIDevice);
+
assertNull(spy.getProcessByName("system_server"));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetIntProperty() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("123").when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertEquals(123, spy.getIntProperty("ro.test.prop", -1));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetIntPropertyNotAnIntegerPropertyReturnsDefaultValue() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("not-an-int").when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertEquals(-1, spy.getIntProperty("ro.test.prop", -1));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetIntPropertyUnknownPropertyReturnsDefaultValue() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn(null).when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertEquals(-1, spy.getIntProperty("ro.test.prop", -1));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetBooleanPropertyReturnsTrue() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("true").when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.getBooleanProperty("ro.test.prop", false));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetBooleanPropertyReturnsFalse() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("no").when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertFalse(spy.getBooleanProperty("ro.test.prop", true));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetBooleanPropertyUnknownPropertyReturnsDefaultValue() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn(null).when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.getBooleanProperty("ro.test.prop", true));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetBooleanPropertyInvalidValueReturnsDefaultValue() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("123").when(spy).getProperty("ro.test.prop");
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.getBooleanProperty("ro.test.prop", true));
- EasyMock.verify(mMockIDevice);
}
@Test
public void testGetProperty_noOutput() throws Exception {
CommandResult res = new CommandResult(CommandStatus.SUCCESS);
res.setStdout("\n");
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- 100,
- (OutputStream) null,
- null,
- "adb",
- "-s",
- "serial",
- "shell",
- "getprop",
- "test"))
- .andReturn(res);
- EasyMock.replay(mMockRunUtil, mMockIDevice);
+ when(mMockRunUtil.runTimedCmd(
+ 100,
+ (OutputStream) null,
+ null,
+ "adb",
+ "-s",
+ "serial",
+ "shell",
+ "getprop",
+ "test"))
+ .thenReturn(res);
+
assertNull(mTestDevice.getProperty("test"));
- EasyMock.verify(mMockRunUtil, mMockIDevice);
}
/** Test get boot history */
@@ -2496,9 +2519,8 @@
history.put(1556238008L, "reboot");
history.put(1556237796L, "reboot");
history.put(1556237725L, "reboot");
- EasyMock.replay(mMockIDevice);
+
assertEquals(history, spy.getBootHistory());
- EasyMock.verify(mMockIDevice);
}
/** Test get empty boot history */
@@ -2506,9 +2528,8 @@
public void testGetBootHistoryEmpty() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("").when(spy).getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.getBootHistory().isEmpty());
- EasyMock.verify(mMockIDevice);
}
/** Test get invalid boot history */
@@ -2516,9 +2537,8 @@
public void testGetBootHistoryInvalid() throws Exception {
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn("invalid output").when(spy).getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.getBootHistory().isEmpty());
- EasyMock.verify(mMockIDevice);
}
/** Test get boot history since */
@@ -2534,9 +2554,8 @@
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
Map<Long, String> history = new LinkedHashMap<Long, String>();
history.put(1556587278L, "kernel_panic");
- EasyMock.replay(mMockIDevice);
+
assertEquals(history, spy.getBootHistorySince(1556238009L, TimeUnit.SECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getBootHistorySince(long, TimeUnit)} on an edge condition. */
@@ -2548,10 +2567,9 @@
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
Map<Long, String> history = new LinkedHashMap<Long, String>();
history.put(1579678463L, "reboot");
- EasyMock.replay(mMockIDevice);
+
// For the same value we should expect it to be part of the reboot.
assertEquals(history, spy.getBootHistorySince(1579678463, TimeUnit.SECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test get boot history since */
@@ -2567,9 +2585,8 @@
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
Map<Long, String> history = new LinkedHashMap<Long, String>();
history.put(1556587278L, "kernel_panic");
- EasyMock.replay(mMockIDevice);
+
assertEquals(history, spy.getBootHistorySince(1556238009000L, TimeUnit.MILLISECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestartedSince */
@@ -2587,14 +2604,13 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertFalse(spy.deviceSoftRestartedSince(1559091923L, TimeUnit.SECONDS));
assertFalse(spy.deviceSoftRestartedSince(1559091923000L, TimeUnit.MILLISECONDS));
assertFalse(spy.deviceSoftRestartedSince(1559091922L, TimeUnit.SECONDS));
assertFalse(spy.deviceSoftRestartedSince(1559091922000L, TimeUnit.MILLISECONDS));
assertTrue(spy.deviceSoftRestartedSince(1559091920L, TimeUnit.SECONDS));
assertTrue(spy.deviceSoftRestartedSince(1559091920000L, TimeUnit.MILLISECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestartedSince return true with system_server stopped */
@@ -2620,11 +2636,11 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
try {
spy.deviceSoftRestartedSince(1559091922L, TimeUnit.SECONDS);
} catch (RuntimeException e) {
- //expected
+ // expected
return;
}
fail("RuntimeException is expected");
@@ -2645,9 +2661,8 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertFalse(spy.deviceSoftRestartedSince(1559091921L, TimeUnit.SECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestartedSince return false with normal reboot */
@@ -2665,9 +2680,8 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.deviceSoftRestartedSince(1559091921L, TimeUnit.SECONDS));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestarted given the previous system_server {@link ProcessInfo} */
@@ -2687,10 +2701,9 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertTrue(spy.deviceSoftRestarted(prev1));
assertFalse(spy.deviceSoftRestarted(prev2));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestarted return true with system_server stopped */
@@ -2718,11 +2731,11 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
try {
spy.deviceSoftRestarted(new ProcessInfo("system", 123, "system_server", 1559000000L));
} catch (RuntimeException e) {
- //expected
+ // expected
return;
}
fail("Abnormal reboot is detected, RuntimeException is expected");
@@ -2743,11 +2756,10 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertFalse(
spy.deviceSoftRestarted(
new ProcessInfo("system", 123, "system_server", 1559000000L)));
- EasyMock.verify(mMockIDevice);
}
/** Test deviceSoftRestarted return true if system_server restarted after normal reboot */
@@ -2765,11 +2777,10 @@
+ " reboot,,1556237725\n")
.when(spy)
.getProperty(DeviceProperties.BOOT_REASON_HISTORY);
- EasyMock.replay(mMockIDevice);
+
assertTrue(
spy.deviceSoftRestarted(
new ProcessInfo("system", 123, "system_server", 1559000000L)));
- EasyMock.verify(mMockIDevice);
}
/** Test validating valid MAC addresses */
@@ -2792,19 +2803,40 @@
@Test
public void testGetMacAddress() throws Exception {
String address = "58:a2:b5:7d:49:24";
- IDevice device = new StubDevice(MOCK_DEVICE_SERIAL) {
- @Override
- public void executeShellCommand(String command, IShellOutputReceiver receiver)
- throws TimeoutException, AdbCommandRejectedException,
- ShellCommandUnresponsiveException, IOException {
- receiver.addOutput(address.getBytes(), 0, address.length());
- }
- };
- mMockIDevice.executeShellCommand(EasyMock.anyObject(), EasyMock.anyObject());
- EasyMock.expectLastCall().andDelegateTo(device).anyTimes();
- EasyMock.replay(mMockIDevice);
+ IDevice device =
+ new StubDevice(MOCK_DEVICE_SERIAL) {
+ @Override
+ public void executeShellCommand(String command, IShellOutputReceiver receiver)
+ throws TimeoutException, AdbCommandRejectedException,
+ ShellCommandUnresponsiveException, IOException {
+ receiver.addOutput(address.getBytes(), 0, address.length());
+ }
+ };
+ mMockIDevice = mock(IDevice.class, AdditionalAnswers.delegatesTo(device));
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ IHostOptions getHostOptions() {
+ return new HostOptions() {
+ @Override
+ public String getNetworkInterface() {
+ return "en0";
+ }
+ };
+ }
+
+ @Override
+ public boolean isAdbTcp() {
+ return true;
+ }
+
+ @Override
+ public boolean isAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+ };
+
assertEquals(address, mTestDevice.getMacAddress());
- EasyMock.verify(mMockIDevice);
}
/** Test querying a device MAC address when the device is in fastboot */
@@ -2818,33 +2850,55 @@
/** Test querying a device MAC address but failing to do so */
@Test
public void testGetMacAddress_failure() throws Exception {
- IDevice device = new StubDevice(MOCK_DEVICE_SERIAL) {
- @Override
- public void executeShellCommand(String command, IShellOutputReceiver receiver)
- throws TimeoutException, AdbCommandRejectedException,
- ShellCommandUnresponsiveException, IOException {
- throw new IOException();
- }
- };
- mMockIDevice.executeShellCommand(EasyMock.anyObject(), EasyMock.anyObject());
- EasyMock.expectLastCall().andDelegateTo(device).anyTimes();
- EasyMock.replay(mMockIDevice);
+ IDevice device =
+ new StubDevice(MOCK_DEVICE_SERIAL) {
+ @Override
+ public void executeShellCommand(String command, IShellOutputReceiver receiver)
+ throws TimeoutException, AdbCommandRejectedException,
+ ShellCommandUnresponsiveException, IOException {
+ throw new IOException();
+ }
+ };
+ mMockIDevice = mock(IDevice.class, AdditionalAnswers.delegatesTo(device));
+ mTestDevice =
+ new TestableAndroidNativeDevice() {
+ @Override
+ IHostOptions getHostOptions() {
+ return new HostOptions() {
+ @Override
+ public String getNetworkInterface() {
+ return "en0";
+ }
+ };
+ }
+
+ @Override
+ public boolean isAdbTcp() {
+ return true;
+ }
+
+ @Override
+ public boolean isAdbRoot() throws DeviceNotAvailableException {
+ return true;
+ }
+ };
+
assertNull(mTestDevice.getMacAddress());
- EasyMock.verify(mMockIDevice);
}
/** Test querying a device MAC address for a stub device */
@Test
public void testGetMacAddress_stubDevice() throws Exception {
String address = "58:a2:b5:7d:49:24";
- IDevice device = new StubDevice(MOCK_DEVICE_SERIAL) {
- @Override
- public void executeShellCommand(String command, IShellOutputReceiver receiver)
- throws TimeoutException, AdbCommandRejectedException,
- ShellCommandUnresponsiveException, IOException {
- receiver.addOutput(address.getBytes(), 0, address.length());
- }
- };
+ IDevice device =
+ new StubDevice(MOCK_DEVICE_SERIAL) {
+ @Override
+ public void executeShellCommand(String command, IShellOutputReceiver receiver)
+ throws TimeoutException, AdbCommandRejectedException,
+ ShellCommandUnresponsiveException, IOException {
+ receiver.addOutput(address.getBytes(), 0, address.length());
+ }
+ };
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -2938,21 +2992,20 @@
SimpleDateFormat format = new SimpleDateFormat("MM-dd HH:mm:ss.mmm");
String dateFormatted = format.format(new Date(date));
- mMockIDevice.executeShellCommand(
- EasyMock.eq(String.format("logcat -v threadtime -t '%s'", dateFormatted)),
- EasyMock.anyObject());
- EasyMock.replay(mMockIDevice);
InputStreamSource res = mTestDevice.getLogcatSince(date);
StreamUtil.close(res);
- EasyMock.verify(mMockIDevice);
+
+ verify(mMockIDevice)
+ .executeShellCommand(
+ Mockito.eq(String.format("logcat -v threadtime -t '%s'", dateFormatted)),
+ Mockito.any());
}
@Test
public void testGetProductVariant() throws Exception {
setGetPropertyExpectation(DeviceProperties.VARIANT, "variant");
- EasyMock.replay(mMockIDevice);
+
assertEquals("variant", mTestDevice.getProductVariant());
- EasyMock.verify(mMockIDevice);
}
@Test
@@ -2997,14 +3050,11 @@
OutputStream stdout = null, stderr = null;
CommandResult res = new CommandResult();
res.setStatus(CommandStatus.SUCCESS);
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- 100, stdout, stderr, "adb", "-s", "serial", "shell", "some",
- "command"))
- .andReturn(res);
- EasyMock.replay(mMockRunUtil, mMockIDevice);
+ when(mMockRunUtil.runTimedCmd(
+ 100, stdout, stderr, "adb", "-s", "serial", "shell", "some", "command"))
+ .thenReturn(res);
+
assertNotNull(mTestDevice.executeShellV2Command("some command"));
- EasyMock.verify(mMockRunUtil, mMockIDevice);
}
/**
@@ -3017,20 +3067,19 @@
CommandResult res = new CommandResult();
res.setStatus(CommandStatus.TIMED_OUT);
res.setStderr("timed out");
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some",
- "command"))
- .andReturn(res)
- .times(2);
- EasyMock.replay(mMockRunUtil, mMockIDevice);
+ when(mMockRunUtil.runTimedCmd(
+ 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some", "command"))
+ .thenReturn(res);
+
try {
mTestDevice.executeShellV2Command("some command", 200L, TimeUnit.MILLISECONDS, 1);
fail("Should have thrown an exception.");
} catch (DeviceUnresponsiveException e) {
// expected
}
- EasyMock.verify(mMockRunUtil, mMockIDevice);
+ verify(mMockRunUtil, times(2))
+ .runTimedCmd(
+ 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some", "command");
}
/**
@@ -3043,19 +3092,18 @@
CommandResult res = new CommandResult();
res.setStatus(CommandStatus.FAILED);
res.setStderr("timed out");
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some",
- "command"))
- .andReturn(res)
- .times(1);
- EasyMock.replay(mMockRunUtil, mMockIDevice);
+ when(mMockRunUtil.runTimedCmd(
+ 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some", "command"))
+ .thenReturn(res);
+
CommandResult result =
mTestDevice.executeShellV2Command("some command", 200L, TimeUnit.MILLISECONDS, 1);
assertNotNull(result);
// The final result is what RunUtil returned, so it contains full status information.
assertSame(res, result);
- EasyMock.verify(mMockRunUtil, mMockIDevice);
+ verify(mMockRunUtil, times(1))
+ .runTimedCmd(
+ 200L, stdout, stderr, "adb", "-s", "serial", "shell", "some", "command");
}
/** Unit test for {@link INativeDevice#setProperty(String, String)}. */
@@ -3071,20 +3119,18 @@
};
CommandResult res = new CommandResult();
res.setStatus(CommandStatus.SUCCESS);
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- 120000,
- stdout,
- stderr,
- "adb",
- "-s",
- "serial",
- "shell",
- "setprop test 'value'"))
- .andReturn(res);
- EasyMock.replay(mMockRunUtil, mMockIDevice);
+ when(mMockRunUtil.runTimedCmd(
+ 120000,
+ stdout,
+ stderr,
+ "adb",
+ "-s",
+ "serial",
+ "shell",
+ "setprop test 'value'"))
+ .thenReturn(res);
+
assertTrue(mTestDevice.setProperty("test", "value"));
- EasyMock.verify(mMockRunUtil, mMockIDevice);
}
/**
@@ -3184,10 +3230,8 @@
TestableAndroidNativeDevice spy = Mockito.spy(mTestDevice);
doReturn(false).when(spy).isAdbRoot();
- EasyMock.replay(mMockIDevice);
List<File> result = spy.getTombstones();
assertEquals(0, result.size());
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getTombstones()}. */
@@ -3202,10 +3246,8 @@
doReturn(new File("tomb1_test")).when(spy).pullFile("/data/tombstones/tomb1");
doReturn(new File("tomb2_test")).when(spy).pullFile("/data/tombstones/tomb2");
- EasyMock.replay(mMockIDevice);
List<File> result = spy.getTombstones();
assertEquals(2, result.size());
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getLaunchApiLevel()} with ro.product.first_api_level being set. */
@@ -3219,9 +3261,8 @@
return 29;
}
};
- EasyMock.replay(mMockIDevice);
+
assertEquals(23, mTestDevice.getLaunchApiLevel());
- EasyMock.verify(mMockIDevice);
}
/**
@@ -3237,9 +3278,8 @@
return 29;
}
};
- EasyMock.replay(mMockIDevice);
+
assertEquals(29, mTestDevice.getLaunchApiLevel());
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getLaunchApiLevel()} with NumberFormatException be asserted. */
@@ -3253,27 +3293,24 @@
return 29;
}
};
- EasyMock.replay(mMockIDevice);
+
assertEquals(29, mTestDevice.getLaunchApiLevel());
- EasyMock.verify(mMockIDevice);
}
private void setGetPropertyExpectation(String property, String value) {
CommandResult stubResult = new CommandResult(CommandStatus.SUCCESS);
stubResult.setStdout(value);
- EasyMock.expect(
- mMockRunUtil.runTimedCmd(
- EasyMock.anyLong(),
- (OutputStream) EasyMock.isNull(),
- EasyMock.isNull(),
- EasyMock.eq("adb"),
- EasyMock.eq("-s"),
- EasyMock.eq("serial"),
- EasyMock.eq("shell"),
- EasyMock.eq("getprop"),
- EasyMock.eq(property)))
- .andReturn(stubResult);
- EasyMock.replay(mMockRunUtil);
+ when(mMockRunUtil.runTimedCmd(
+ Mockito.anyLong(),
+ (OutputStream) Mockito.isNull(),
+ Mockito.isNull(),
+ Mockito.eq("adb"),
+ Mockito.eq("-s"),
+ Mockito.eq("serial"),
+ Mockito.eq("shell"),
+ Mockito.eq("getprop"),
+ Mockito.eq(property)))
+ .thenReturn(stubResult);
}
/** Test {@link NativeDevice#getFastbootSerialNumber()} with USB adb. */
@@ -3286,9 +3323,8 @@
return false;
}
};
- EasyMock.replay(mMockIDevice);
+
assertEquals(MOCK_DEVICE_SERIAL, mTestDevice.getFastbootSerialNumber());
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getFastbootSerialNumber()} with non-root TCP adb. */
@@ -3304,6 +3340,7 @@
receiver.addOutput(address.getBytes(), 0, address.length());
}
};
+ mMockIDevice = mock(IDevice.class, AdditionalAnswers.delegatesTo(device));
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -3336,12 +3373,8 @@
return true;
}
};
- mMockIDevice.executeShellCommand(EasyMock.anyObject(), EasyMock.anyObject());
- EasyMock.expectLastCall().andDelegateTo(device).anyTimes();
- EasyMock.replay(mMockIDevice);
assertEquals(
"tcp:fe80:0:0:0:230:1bff:feba:8128%en0", mTestDevice.getFastbootSerialNumber());
- EasyMock.verify(mMockIDevice);
}
/** Test {@link NativeDevice#getFastbootSerialNumber()} with root TCP adb. */
@@ -3357,6 +3390,7 @@
receiver.addOutput(address.getBytes(), 0, address.length());
}
};
+ mMockIDevice = mock(IDevice.class, AdditionalAnswers.delegatesTo(device));
mTestDevice =
new TestableAndroidNativeDevice() {
@Override
@@ -3379,12 +3413,7 @@
return true;
}
};
-
- mMockIDevice.executeShellCommand(EasyMock.anyObject(), EasyMock.anyObject());
- EasyMock.expectLastCall().andDelegateTo(device).anyTimes();
- EasyMock.replay(mMockIDevice);
assertEquals(
"tcp:fe80:0:0:0:230:1bff:feba:8128%en0", mTestDevice.getFastbootSerialNumber());
- EasyMock.verify(mMockIDevice);
}
}
