Merge "End the suffering caused by ConnectivityServiceMock." am: 75cefa5962 am: 925c233f2d (ce3fa310) · Commits · e / os / android_frameworks_opt_telephony

tests/telephonytests/src/com/android/internal/telephony/dataconnection/TelephonyNetworkFactoryTest.java

+19 −1

Original line number	Diff line number	Diff line
		@@ -21,16 +21,19 @@ import static com.android.internal.telephony.TelephonyTestUtils.waitForMs;
		import static org.junit.Assert.assertEquals;
		import static org.mockito.ArgumentMatchers.any;
		import static org.mockito.ArgumentMatchers.anyInt;
		import static org.mockito.ArgumentMatchers.anyString;
		import static org.mockito.Mockito.doAnswer;

		import android.content.Context;
		import android.net.ConnectivityManager;
		import android.net.IConnectivityManager;
		import android.net.NetworkCapabilities;
		import android.net.NetworkRequest;
		import android.net.StringNetworkSpecifier;
		import android.os.Binder;
		import android.os.HandlerThread;
		import android.os.Looper;
		import android.os.Messenger;
		import android.telephony.Rlog;
		import android.test.suitebuilder.annotation.SmallTest;

		@@ -58,6 +61,8 @@ public class TelephonyNetworkFactoryTest extends TelephonyTest {

		@Mock
		private RadioConfig mMockRadioConfig;
		@Mock
		private IConnectivityManager mIConnectivityManager;

		private String mTestName = "";

		@@ -119,6 +124,19 @@ public class TelephonyNetworkFactoryTest extends TelephonyTest {
		mNetworkRequestList.remove((NetworkRequest) invocation.getArguments()[0]);
		return null;
		}).when(mDcTracker).releaseNetwork(any(), anyInt(), any());

		doAnswer(invocation -> {
		mConnectivityServiceMock.registerNetworkFactory(
		(Messenger) invocation.getArguments()[0],
		(String) invocation.getArguments()[1]);
		return null;
		}).when(mIConnectivityManager).registerNetworkFactory(any(), anyString());

		doAnswer(invocation -> {
		mConnectivityServiceMock.unregisterNetworkFactory(
		(Messenger) invocation.getArguments()[0]);
		return null;
		}).when(mIConnectivityManager).unregisterNetworkFactory(any());
		}

		@After
		@@ -132,7 +150,7 @@ public class TelephonyNetworkFactoryTest extends TelephonyTest {
		private void createMockedTelephonyComponents(int numberOfPhones) throws Exception {
		mConnectivityServiceMock = new ConnectivityServiceMock(mContext);
		mContextFixture.setSystemService(Context.CONNECTIVITY_SERVICE,
		new ConnectivityManager(mContext, mConnectivityServiceMock));
		new ConnectivityManager(mContext, mIConnectivityManager));
		mTelephonyRegistryMock = new TelephonyRegistryMock();
		mPhoneSwitcherMock = new PhoneSwitcherMock(numberOfPhones, mLooper);
		mSubscriptionControllerMock = new SubscriptionControllerMock(mContext,

tests/telephonytests/src/com/android/internal/telephony/mocks/ConnectivityServiceMock.java

+10 −427

Original line number	Diff line number	Diff line
		@@ -19,53 +19,32 @@ package com.android.internal.telephony.mocks;
		import static android.net.NetworkCapabilities.NET_CAPABILITY_INTERNET;
		import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_RESTRICTED;

		import android.annotation.Nullable;
		import android.app.PendingIntent;
		import android.content.Context;
		import android.content.Intent;
		import android.net.ConnectionInfo;
		import android.net.ConnectivityManager;
		import android.net.IConnectivityManager;
		import android.net.LinkProperties;
		import android.net.Network;
		import android.net.NetworkCapabilities;
		import android.net.NetworkInfo;
		import android.net.NetworkMisc;
		import android.net.NetworkQuotaInfo;
		import android.net.NetworkRequest;
		import android.net.NetworkState;
		import android.net.ProxyInfo;
		import android.os.Binder;
		import android.os.Bundle;
		import android.os.Handler;
		import android.os.HandlerThread;
		import android.os.IBinder;
		import android.os.Looper;
		import android.os.Message;
		import android.os.Messenger;
		import android.os.ParcelFileDescriptor;
		import android.os.Process;
		import android.os.RemoteException;
		import android.os.ResultReceiver;
		import android.util.Slog;

		import com.android.internal.annotations.VisibleForTesting;
		import com.android.internal.net.LegacyVpnInfo;
		import com.android.internal.net.VpnConfig;
		import com.android.internal.net.VpnInfo;
		import com.android.internal.net.VpnProfile;
		import com.android.internal.util.AsyncChannel;
		import com.android.server.connectivity.NetworkAgentInfo;

		import java.io.FileDescriptor;
		import java.io.PrintWriter;
		import java.util.HashMap;
		import java.util.List;

		/**
		* @hide
		*/
		public class ConnectivityServiceMock extends IConnectivityManager.Stub
		implements PendingIntent.OnFinished {
		public class ConnectivityServiceMock {
		private static final String TAG = "ConnectivityServiceMock";
		private static final boolean DBG = true;
		private static final boolean VDBG = true;
		@@ -339,6 +318,14 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		}
		}

		private int getCallingUid() {
		return Process.myUid();
		}

		private int getCallingPid() {
		return Process.myPid();
		}

		private class NetworkRequestInfo implements IBinder.DeathRecipient {
		static final boolean REQUEST = true;
		static final boolean LISTEN = false;
		@@ -406,299 +393,6 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		return mNextNetworkRequestId++;
		}

		@Override
		public NetworkInfo getActiveNetworkInfo() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public Network getActiveNetwork() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public Network getActiveNetworkForUid(int uid, boolean ignoreBlocked) {
		throw new RuntimeException("not implemented");
		}

		public NetworkInfo getActiveNetworkInfoUnfiltered() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkInfo getActiveNetworkInfoForUid(int uid, boolean ignoreBlocked) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkInfo getNetworkInfo(int networkType) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkInfo getNetworkInfoForUid(Network network, int uid, boolean ignoreBlocked) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkInfo[] getAllNetworkInfo() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public Network getNetworkForType(int networkType) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public Network[] getAllNetworks() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkCapabilities[] getDefaultNetworkCapabilitiesForUser(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isNetworkSupported(int networkType) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public LinkProperties getActiveLinkProperties() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public LinkProperties getLinkPropertiesForType(int networkType) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public LinkProperties getLinkProperties(Network network) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkCapabilities getNetworkCapabilities(Network network) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkState[] getAllNetworkState() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkQuotaInfo getActiveNetworkQuotaInfo() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isActiveNetworkMetered() {
		throw new RuntimeException("not implemented");
		}

		public boolean requestRouteToHostAddress(int networkType, byte[] hostAddress) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public int getRestoreDefaultNetworkDelay(int networkType) {
		throw new RuntimeException("not implemented");
		}

		@Override
		protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
		throw new RuntimeException("not implemented");
		}

		public void setAcceptUnvalidated(Network network, boolean accept, boolean always) {
		throw new RuntimeException("not implemented");
		}

		public void setAvoidUnvalidated(Network network) {
		throw new RuntimeException("not implemented");
		}

		public void startCaptivePortalApp(Network network) {
		throw new RuntimeException("not implemented");
		}

		public int getMultipathPreference(Network network) {
		throw new RuntimeException("not implemented");
		}

		public int tether(String iface, String callerPkg) {
		throw new RuntimeException("not implemented");
		}

		public int untether(String iface, String callerPkg) {
		throw new RuntimeException("not implemented");
		}

		public int getLastTetherError(String iface) {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetherableUsbRegexs() {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetherableWifiRegexs() {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetherableBluetoothRegexs() {
		throw new RuntimeException("not implemented");
		}

		public int setUsbTethering(boolean enable, String callerPkg) {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetherableIfaces() {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetheredIfaces() {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetheringErroredIfaces() {
		throw new RuntimeException("not implemented");
		}

		public String[] getTetheredDhcpRanges() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isTetheringSupported(String callerPkg) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void startTethering(int type, ResultReceiver receiver, boolean showProvisioningUi,
		String callerPkg) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void stopTethering(int type, String callerPkg) {
		throw new RuntimeException("not implemented");
		}


		public void reportInetCondition(int networkType, int percentage) {
		throw new RuntimeException("not implemented");
		}

		public void reportNetworkConnectivity(Network network, boolean hasConnectivity) {
		throw new RuntimeException("not implemented");
		}

		public ProxyInfo getProxyForNetwork(Network network) {
		throw new RuntimeException("not implemented");
		}

		public void setGlobalProxy(ProxyInfo proxyProperties) {
		throw new RuntimeException("not implemented");
		}

		public ProxyInfo getGlobalProxy() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean prepareVpn(@Nullable String oldPackage, @Nullable String newPackage,
		int userId) {
		throw new RuntimeException("not implemented");
		}

		public void setVpnPackageAuthorization(String packageName, int userId, boolean authorized) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public ParcelFileDescriptor establishVpn(VpnConfig config) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void startLegacyVpn(VpnProfile profile) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public LegacyVpnInfo getLegacyVpnInfo(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public VpnInfo[] getAllVpnInfo() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public VpnConfig getVpnConfig(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean updateLockdownVpn() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isAlwaysOnVpnPackageSupported(int userId, String packageName) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean setAlwaysOnVpnPackage(int userId, String packageName, boolean lockdownEnabled,
		List<String> lockdownWhitelist) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public String getAlwaysOnVpnPackage(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isVpnLockdownEnabled(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public List<String> getVpnLockdownWhitelist(int userId) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public int checkMobileProvisioning(int suggestedTimeOutMs) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public String getMobileProvisioningUrl() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void setProvisioningNotificationVisible(boolean visible, int networkType,
		String action) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void setAirplaneMode(boolean enable) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkRequest requestNetwork(NetworkCapabilities networkCapabilities,
		Messenger messenger, int timeoutMs, IBinder binder, int legacyType) {
		networkCapabilities = new NetworkCapabilities(networkCapabilities);
		@@ -717,42 +411,11 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		return networkRequest;
		}

		@Override
		public boolean requestBandwidthUpdate(Network network) {
		throw new RuntimeException("not implemented");
		}


		@Override
		public NetworkRequest pendingRequestForNetwork(NetworkCapabilities networkCapabilities,
		PendingIntent operation) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void releasePendingNetworkRequest(PendingIntent operation) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkRequest listenForNetwork(NetworkCapabilities networkCapabilities,
		Messenger messenger, IBinder binder) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void pendingListenForNetwork(NetworkCapabilities networkCapabilities,
		PendingIntent operation) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void releaseNetworkRequest(NetworkRequest networkRequest) {
		mHandler.sendMessage(mHandler.obtainMessage(EVENT_RELEASE_NETWORK_REQUEST, getCallingUid(),
		0, networkRequest));
		}

		@Override
		public void registerNetworkFactory(Messenger messenger, String name) {
		NetworkFactoryInfo nfi = new NetworkFactoryInfo(name, messenger, new AsyncChannel());
		mHandler.sendMessage(mHandler.obtainMessage(EVENT_REGISTER_NETWORK_FACTORY, nfi));
		@@ -764,16 +427,10 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		nfi.asyncChannel.connect(mContext, mTrackerHandler, nfi.messenger);
		}

		@Override
		public void unregisterNetworkFactory(Messenger messenger) {
		mHandler.sendMessage(mHandler.obtainMessage(EVENT_UNREGISTER_NETWORK_FACTORY, messenger));
		}

		@Override
		public byte[] getNetworkWatchlistConfigHash() {
		throw new RuntimeException("not implemented");
		}

		private void handleUnregisterNetworkFactory(Messenger messenger) {
		NetworkFactoryInfo nfi = mNetworkFactoryInfos.remove(messenger);
		if (nfi == null) {
		@@ -925,55 +582,6 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		private void rematchAllNetworksAndRequests(NetworkAgentInfo changed, int oldScore) {
		}

		@Override
		public void onSendFinished(PendingIntent pendingIntent, Intent intent, int resultCode,
		String resultData, Bundle resultExtras) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean addVpnAddress(String address, int prefixLength) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean removeVpnAddress(String address, int prefixLength) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean setUnderlyingNetworksForVpn(Network[] networks) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public String getCaptivePortalServerUrl() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void startNattKeepalive(Network network, int intervalSeconds, Messenger messenger,
		IBinder binder, String srcAddr, int srcPort, String dstAddr) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void startNattKeepaliveWithFd(Network network, FileDescriptor fd, int resourceId,
		int intervalSeconds, Messenger messenger,
		IBinder binder, String srcAddr, String dstAddr) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void stopKeepalive(Network network, int slot) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public void factoryReset() {
		throw new RuntimeException("not implemented");
		}

		@VisibleForTesting
		public NetworkRequest defaultRequest = null;
		@VisibleForTesting
		@@ -997,29 +605,4 @@ public class ConnectivityServiceMock extends IConnectivityManager.Stub
		releaseNetworkRequest(defaultRequest);
		defaultRequest = null;
		}

		@Override
		public int getConnectionOwnerUid(ConnectionInfo connectionInfo) {
		throw new RuntimeException("not implemented");
		}

		@Override
		public NetworkRequest getDefaultRequest() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isCallerCurrentAlwaysOnVpnApp() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean isCallerCurrentAlwaysOnVpnLockdownApp() {
		throw new RuntimeException("not implemented");
		}

		@Override
		public boolean getAvoidBadWifi() {
		return true;
		}
		}

tests/telephonytests/src/com/android/internal/telephony/mocks/OWNERS

deleted100644 → 0

+0 −6

Original line number	Diff line number	Diff line
		# Re-list all owners appearing in the root OWNERS file for this project
		# This allows adding new owners for specific files using the per-file rule.
		per-file * = amitmahajan@google.com,breadley@google.com,fionaxu@google.com
		per-file * = jackyu@google.com,rgreenwalt@google.com,tgunn@google.com

		per-file ConnectivityServiceMock.java=ek@google.com,jchalard@google.com,lorenzo@google.com,reminv@google.com