LineageOS/android_packages_modules_Connectivity
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge "Networking unit tests: fix some flaky tests"

Browse Source 
am: 501bae6492

Change-Id: I6815e732f334d11208ff12af4023912593d96499
This commit is contained in:
Hugo Benichi
2017-07-03 09:35:06 +00:00
committed by android-build-merger
parent 81173713d7 44ceaa602e
commit ae3dac0601
4 changed files with 24 additions and 85 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tests/net/java/android/net/nsd/NsdManagerTest.java
View File

@@ -349,7 +349,6 @@ public class NsdManagerTest {
chan.connect(mContext, this, msg.replyTo); chan.connect(mContext, this, msg.replyTo);
chan.sendMessage(AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED); chan.sendMessage(AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED);
} }
} }
public static MockServiceHandler create(Context context) { public static MockServiceHandler create(Context context) {

20
tests/net/java/com/android/server/ConnectivityServiceTest.java
View File

@@ -23,6 +23,8 @@ import static android.net.ConnectivityManager.TYPE_WIFI;
import static android.net.ConnectivityManager.getNetworkTypeName; import static android.net.ConnectivityManager.getNetworkTypeName;
import static android.net.NetworkCapabilities.*; import static android.net.NetworkCapabilities.*;
import static com.android.internal.util.TestUtils.waitForIdleHandler;
import static org.mockito.Mockito.anyBoolean; import static org.mockito.Mockito.anyBoolean;
import static org.mockito.Mockito.anyInt; import static org.mockito.Mockito.anyInt;
import static org.mockito.Mockito.eq; import static org.mockito.Mockito.eq;
@@ -212,20 +214,8 @@ public class ConnectivityServiceTest extends AndroidTestCase {
} }
} }
/** public void waitForIdle(int timeoutMsAsInt) {
* Block until the given handler becomes idle, or until timeoutMs has passed. long timeoutMs = timeoutMsAsInt;
*/
private static void waitForIdleHandler(HandlerThread handlerThread, int timeoutMs) {
final ConditionVariable cv = new ConditionVariable();
final Handler handler = new Handler(handlerThread.getLooper());
handler.post(() -> cv.open());
if (!cv.block(timeoutMs)) {
fail("HandlerThread " + handlerThread.getName() +
" did not become idle after " + timeoutMs + " ms");
}
}
public void waitForIdle(int timeoutMs) {
waitForIdleHandler(mService.mHandlerThread, timeoutMs); waitForIdleHandler(mService.mHandlerThread, timeoutMs);
waitForIdle(mCellNetworkAgent, timeoutMs); waitForIdle(mCellNetworkAgent, timeoutMs);
waitForIdle(mWiFiNetworkAgent, timeoutMs); waitForIdle(mWiFiNetworkAgent, timeoutMs);
@@ -233,7 +223,7 @@ public class ConnectivityServiceTest extends AndroidTestCase {
waitForIdleHandler(mService.mHandlerThread, timeoutMs); waitForIdleHandler(mService.mHandlerThread, timeoutMs);
} }
public void waitForIdle(MockNetworkAgent agent, int timeoutMs) { public void waitForIdle(MockNetworkAgent agent, long timeoutMs) {
if (agent == null) { if (agent == null) {
return; return;
} }

29
tests/net/java/com/android/server/net/NetworkStatsObserversTest.java
View File

@@ -27,6 +27,8 @@ import static android.net.NetworkTemplate.buildTemplateWifiWildcard;
import static android.net.TrafficStats.MB_IN_BYTES; import static android.net.TrafficStats.MB_IN_BYTES;
import static android.text.format.DateUtils.MINUTE_IN_MILLIS; import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
import static com.android.internal.util.TestUtils.waitForIdleHandler;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue; import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail; import static org.junit.Assert.fail;
@@ -56,7 +58,6 @@ import android.util.ArrayMap;
import com.android.internal.net.VpnInfo; import com.android.internal.net.VpnInfo;
import com.android.server.net.NetworkStatsService; import com.android.server.net.NetworkStatsService;
import com.android.server.net.NetworkStatsServiceTest.IdleableHandlerThread;
import com.android.server.net.NetworkStatsServiceTest.LatchedHandler; import com.android.server.net.NetworkStatsServiceTest.LatchedHandler;
import java.util.ArrayList; import java.util.ArrayList;
@@ -102,7 +103,7 @@ public class NetworkStatsObserversTest {
private long mElapsedRealtime; private long mElapsedRealtime;
private IdleableHandlerThread mObserverHandlerThread; private HandlerThread mObserverHandlerThread;
private Handler mObserverNoopHandler; private Handler mObserverNoopHandler;
private LatchedHandler mHandler; private LatchedHandler mHandler;
@@ -118,7 +119,7 @@ public class NetworkStatsObserversTest {
public void setUp() throws Exception { public void setUp() throws Exception {
MockitoAnnotations.initMocks(this); MockitoAnnotations.initMocks(this);
mObserverHandlerThread = new IdleableHandlerThread("HandlerThread"); mObserverHandlerThread = new HandlerThread("HandlerThread");
mObserverHandlerThread.start(); mObserverHandlerThread.start();
final Looper observerLooper = mObserverHandlerThread.getLooper(); final Looper observerLooper = mObserverHandlerThread.getLooper();
mStatsObservers = new NetworkStatsObservers() { mStatsObservers = new NetworkStatsObservers() {
@@ -319,7 +320,7 @@ public class NetworkStatsObserversTest {
xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces, xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces,
VPN_INFO, TEST_START); VPN_INFO, TEST_START);
waitForObserverToIdle(); waitForObserverToIdle();
assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.mLastMessageType); assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.lastMessageType);
} }
@Test @Test
@@ -356,7 +357,7 @@ public class NetworkStatsObserversTest {
xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces, xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces,
VPN_INFO, TEST_START); VPN_INFO, TEST_START);
waitForObserverToIdle(); waitForObserverToIdle();
assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.mLastMessageType); assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.lastMessageType);
} }
@Test @Test
@@ -429,7 +430,7 @@ public class NetworkStatsObserversTest {
xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces, xtSnapshot, uidSnapshot, mActiveIfaces, mActiveUidIfaces,
VPN_INFO, TEST_START); VPN_INFO, TEST_START);
waitForObserverToIdle(); waitForObserverToIdle();
assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.mLastMessageType); assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, mHandler.lastMessageType);
} }
@Test @Test
@@ -470,19 +471,7 @@ public class NetworkStatsObserversTest {
} }
private void waitForObserverToIdle() { private void waitForObserverToIdle() {
waitForIdleLooper(mObserverHandlerThread.getLooper(), WAIT_TIMEOUT_MS); waitForIdleHandler(mObserverHandlerThread, WAIT_TIMEOUT_MS);
waitForIdleLooper(mHandler.getLooper(), WAIT_TIMEOUT_MS); waitForIdleHandler(mHandler, WAIT_TIMEOUT_MS);
} }
// TODO: unify with ConnectivityService.waitForIdleHandler and
// NetworkServiceStatsTest.IdleableHandlerThread
private static void waitForIdleLooper(Looper looper, long timeoutMs) {
final ConditionVariable cv = new ConditionVariable();
final Handler handler = new Handler(looper);
handler.post(() -> cv.open());
if (!cv.block(timeoutMs)) {
fail("Looper did not become idle after " + timeoutMs + " ms");
}
}
} }

59
tests/net/java/com/android/server/net/NetworkStatsServiceTest.java
View File

@@ -45,6 +45,7 @@ import static android.text.format.DateUtils.MINUTE_IN_MILLIS;
import static android.text.format.DateUtils.WEEK_IN_MILLIS; import static android.text.format.DateUtils.WEEK_IN_MILLIS;
import static com.android.server.net.NetworkStatsService.ACTION_NETWORK_STATS_POLL; import static com.android.server.net.NetworkStatsService.ACTION_NETWORK_STATS_POLL;
import static com.android.internal.util.TestUtils.waitForIdleHandler;
import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNotNull;
@@ -154,7 +155,7 @@ public class NetworkStatsServiceTest {
private @Mock IConnectivityManager mConnManager; private @Mock IConnectivityManager mConnManager;
private @Mock IBinder mBinder; private @Mock IBinder mBinder;
private @Mock AlarmManager mAlarmManager; private @Mock AlarmManager mAlarmManager;
private IdleableHandlerThread mHandlerThread; private HandlerThread mHandlerThread;
private Handler mHandler; private Handler mHandler;
private NetworkStatsService mService; private NetworkStatsService mService;
@@ -181,7 +182,7 @@ public class NetworkStatsServiceTest {
mServiceContext, mNetManager, mAlarmManager, wakeLock, mTime, mServiceContext, mNetManager, mAlarmManager, wakeLock, mTime,
TelephonyManager.getDefault(), mSettings, new NetworkStatsObservers(), TelephonyManager.getDefault(), mSettings, new NetworkStatsObservers(),
mStatsDir, getBaseDir(mStatsDir)); mStatsDir, getBaseDir(mStatsDir));
mHandlerThread = new IdleableHandlerThread("HandlerThread"); mHandlerThread = new HandlerThread("HandlerThread");
mHandlerThread.start(); mHandlerThread.start();
Handler.Callback callback = new NetworkStatsService.HandlerCallback(mService); Handler.Callback callback = new NetworkStatsService.HandlerCallback(mService);
mHandler = new Handler(mHandlerThread.getLooper(), callback); mHandler = new Handler(mHandlerThread.getLooper(), callback);
@@ -886,7 +887,7 @@ public class NetworkStatsServiceTest {
// Send dummy message to make sure that any previous message has been handled // Send dummy message to make sure that any previous message has been handled
mHandler.sendMessage(mHandler.obtainMessage(-1)); mHandler.sendMessage(mHandler.obtainMessage(-1));
mHandlerThread.waitForIdle(WAIT_TIMEOUT); waitForIdleHandler(mHandler, WAIT_TIMEOUT);
@@ -908,7 +909,7 @@ public class NetworkStatsServiceTest {
assertNetworkTotal(sTemplateWifi, 1024L, 1L, 2048L, 2L, 0); assertNetworkTotal(sTemplateWifi, 1024L, 1L, 2048L, 2L, 0);
// make sure callback has not being called // make sure callback has not being called
assertEquals(INVALID_TYPE, latchedHandler.mLastMessageType); assertEquals(INVALID_TYPE, latchedHandler.lastMessageType);
// and bump forward again, with counters going higher. this is // and bump forward again, with counters going higher. this is
// important, since it will trigger the data usage callback // important, since it will trigger the data usage callback
@@ -926,7 +927,7 @@ public class NetworkStatsServiceTest {
// Wait for the caller to ack receipt of CALLBACK_LIMIT_REACHED // Wait for the caller to ack receipt of CALLBACK_LIMIT_REACHED
assertTrue(cv.block(WAIT_TIMEOUT)); assertTrue(cv.block(WAIT_TIMEOUT));
assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, latchedHandler.mLastMessageType); assertEquals(NetworkStatsManager.CALLBACK_LIMIT_REACHED, latchedHandler.lastMessageType);
cv.close(); cv.close();
// Allow binder to disconnect // Allow binder to disconnect
@@ -937,7 +938,7 @@ public class NetworkStatsServiceTest {
// Wait for the caller to ack receipt of CALLBACK_RELEASED // Wait for the caller to ack receipt of CALLBACK_RELEASED
assertTrue(cv.block(WAIT_TIMEOUT)); assertTrue(cv.block(WAIT_TIMEOUT));
assertEquals(NetworkStatsManager.CALLBACK_RELEASED, latchedHandler.mLastMessageType); assertEquals(NetworkStatsManager.CALLBACK_RELEASED, latchedHandler.lastMessageType);
// Make sure that the caller binder gets disconnected // Make sure that the caller binder gets disconnected
verify(mBinder).unlinkToDeath(any(IBinder.DeathRecipient.class), anyInt()); verify(mBinder).unlinkToDeath(any(IBinder.DeathRecipient.class), anyInt());
@@ -1203,12 +1204,12 @@ public class NetworkStatsServiceTest {
mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL)); mServiceContext.sendBroadcast(new Intent(ACTION_NETWORK_STATS_POLL));
// Send dummy message to make sure that any previous message has been handled // Send dummy message to make sure that any previous message has been handled
mHandler.sendMessage(mHandler.obtainMessage(-1)); mHandler.sendMessage(mHandler.obtainMessage(-1));
mHandlerThread.waitForIdle(WAIT_TIMEOUT); waitForIdleHandler(mHandler, WAIT_TIMEOUT);
} }
static class LatchedHandler extends Handler { static class LatchedHandler extends Handler {
private final ConditionVariable mCv; private final ConditionVariable mCv;
int mLastMessageType = INVALID_TYPE; int lastMessageType = INVALID_TYPE;
LatchedHandler(Looper looper, ConditionVariable cv) { LatchedHandler(Looper looper, ConditionVariable cv) {
super(looper); super(looper);
@@ -1217,49 +1218,9 @@ public class NetworkStatsServiceTest {
@Override @Override
public void handleMessage(Message msg) { public void handleMessage(Message msg) {
mLastMessageType = msg.what; lastMessageType = msg.what;
mCv.open(); mCv.open();
super.handleMessage(msg); super.handleMessage(msg);
} }
} }
/**
* A subclass of HandlerThread that allows callers to wait for it to become idle. waitForIdle
* will return immediately if the handler is already idle.
*/
static class IdleableHandlerThread extends HandlerThread {
private IdleHandler mIdleHandler;
public IdleableHandlerThread(String name) {
super(name);
}
public void waitForIdle(long timeoutMs) {
final ConditionVariable cv = new ConditionVariable();
final MessageQueue queue = getLooper().getQueue();
synchronized (queue) {
if (queue.isIdle()) {
return;
}
assertNull("BUG: only one idle handler allowed", mIdleHandler);
mIdleHandler = new IdleHandler() {
public boolean queueIdle() {
cv.open();
mIdleHandler = null;
return false; // Remove the handler.
}
};
queue.addIdleHandler(mIdleHandler);
}
if (!cv.block(timeoutMs)) {
fail("HandlerThread " + getName() + " did not become idle after " + timeoutMs
+ " ms");
queue.removeIdleHandler(mIdleHandler);
}
}
}
} }