Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Add tests for SharedConnectivityService" into udc-dev

Browse Source
This commit is contained in:
Isaac Katzenelson
2023-03-17 21:02:49 +00:00
committed by Android (Google) Code Review
parent 6e07340e5e 76fe166609
commit ee0d3a4e9d
3 changed files with 188 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
core/api/test-current.txt
View File

@@ -2033,6 +2033,7 @@ package android.net.wifi.sharedconnectivity.service {
public abstract class SharedConnectivityService extends android.app.Service {
method public void onBind();
method public final void setCountdownLatch(@Nullable java.util.concurrent.CountDownLatch);
}
}

15
wifi/java/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityService.java
View File

@@ -46,6 +46,7 @@ import com.android.internal.R;
import java.util.Collections;
import java.util.List;
import java.util.Objects;
import java.util.concurrent.CountDownLatch;
/**
@@ -77,6 +78,8 @@ public abstract class SharedConnectivityService extends Service {
new KnownNetworkConnectionStatus.Builder()
.setStatus(KnownNetworkConnectionStatus.CONNECTION_STATUS_UNKNOWN)
.setExtras(Bundle.EMPTY).build();
// Used for testing
private CountDownLatch mCountDownLatch;
@Override
@Nullable
@@ -265,12 +268,24 @@ public abstract class SharedConnectivityService extends Service {
public void onBind() {
}
/** @hide */
@TestApi
public final void setCountdownLatch(@Nullable CountDownLatch latch) {
mCountDownLatch = latch;
}
private void onRegisterCallback(ISharedConnectivityCallback callback) {
mRemoteCallbackList.register(callback);
if (mCountDownLatch != null) {
mCountDownLatch.countDown();
}
}
private void onUnregisterCallback(ISharedConnectivityCallback callback) {
mRemoteCallbackList.unregister(callback);
if (mCountDownLatch != null) {
mCountDownLatch.countDown();
}
}
/**

176
wifi/tests/src/android/net/wifi/sharedconnectivity/service/SharedConnectivityServiceTest.java
View File

@@ -26,7 +26,10 @@ import static android.net.wifi.sharedconnectivity.app.NetworkProviderInfo.DEVICE
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.content.Context;
@@ -39,6 +42,7 @@ import android.net.wifi.sharedconnectivity.app.KnownNetworkConnectionStatus;
import android.net.wifi.sharedconnectivity.app.NetworkProviderInfo;
import android.net.wifi.sharedconnectivity.app.SharedConnectivitySettingsState;
import android.os.Bundle;
import android.os.IBinder;
import android.os.Looper;
import android.os.RemoteException;
@@ -51,12 +55,16 @@ import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
/**
* Unit tests for {@link SharedConnectivityService}.
*/
@SmallTest
public class SharedConnectivityServiceTest {
private static final int LATCH_TIMEOUT = 2;
private static final NetworkProviderInfo NETWORK_PROVIDER_INFO =
new NetworkProviderInfo.Builder("TEST_NAME", "TEST_MODEL")
.setDeviceType(DEVICE_TYPE_TABLET).setConnectionStrength(2)
@@ -75,7 +83,7 @@ public class SharedConnectivityServiceTest {
.addSecurityType(SECURITY_TYPE_EAP).setNetworkProviderInfo(
NETWORK_PROVIDER_INFO).build();
private static final List<KnownNetwork> KNOWN_NETWORKS = List.of(KNOWN_NETWORK);
private static final HotspotNetworkConnectionStatus TETHER_NETWORK_CONNECTION_STATUS =
private static final HotspotNetworkConnectionStatus HOTSPOT_NETWORK_CONNECTION_STATUS =
new HotspotNetworkConnectionStatus.Builder().setStatus(CONNECTION_STATUS_UNKNOWN)
.setHotspotNetwork(HOTSPOT_NETWORK).setExtras(Bundle.EMPTY).build();
private static final KnownNetworkConnectionStatus KNOWN_NETWORK_CONNECTION_STATUS =
@@ -88,25 +96,77 @@ public class SharedConnectivityServiceTest {
@Mock
Resources mResources;
@Mock
ISharedConnectivityCallback mCallback;
@Mock
IBinder mBinder;
static class FakeSharedConnectivityService extends SharedConnectivityService {
public void attachBaseContext(Context context) {
super.attachBaseContext(context);
}
private HotspotNetwork mConnectedHotspotNetwork;
private HotspotNetwork mDisconnectedHotspotNetwork;
private KnownNetwork mConnectedKnownNetwork;
private KnownNetwork mForgottenKnownNetwork;
private CountDownLatch mLatch;
public HotspotNetwork getConnectedHotspotNetwork() {
return mConnectedHotspotNetwork;
}
public HotspotNetwork getDisconnectedHotspotNetwork() {
return mDisconnectedHotspotNetwork;
}
public KnownNetwork getConnectedKnownNetwork() {
return mConnectedKnownNetwork;
}
public KnownNetwork getForgottenKnownNetwork() {
return mForgottenKnownNetwork;
}
public void initializeLatch() {
mLatch = new CountDownLatch(1);
}
public CountDownLatch getLatch() {
return mLatch;
}
@Override
public void onConnectHotspotNetwork(@NonNull HotspotNetwork network) {
mConnectedHotspotNetwork = network;
if (mLatch != null) {
mLatch.countDown();
}
}
@Override
public void onDisconnectHotspotNetwork(@NonNull HotspotNetwork network) {
mDisconnectedHotspotNetwork = network;
if (mLatch != null) {
mLatch.countDown();
}
}
@Override
public void onConnectKnownNetwork(@NonNull KnownNetwork network) {
mConnectedKnownNetwork = network;
if (mLatch != null) {
mLatch.countDown();
}
}
@Override
public void onForgetKnownNetwork(@NonNull KnownNetwork network) {
mForgottenKnownNetwork = network;
if (mLatch != null) {
mLatch.countDown();
}
}
}
@@ -165,10 +225,10 @@ public class SharedConnectivityServiceTest {
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
service.updateHotspotNetworkConnectionStatus(TETHER_NETWORK_CONNECTION_STATUS);
service.updateHotspotNetworkConnectionStatus(HOTSPOT_NETWORK_CONNECTION_STATUS);
assertThat(binder.getHotspotNetworkConnectionStatus())
.isEqualTo(TETHER_NETWORK_CONNECTION_STATUS);
.isEqualTo(HOTSPOT_NETWORK_CONNECTION_STATUS);
}
@Test
@@ -225,7 +285,115 @@ public class SharedConnectivityServiceTest {
assertThat(SharedConnectivityService.areKnownNetworksEnabledForService(mContext)).isFalse();
}
private SharedConnectivityService createService() {
@Test
public void connectHotspotNetwork() throws RemoteException, InterruptedException {
FakeSharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
service.initializeLatch();
binder.connectHotspotNetwork(HOTSPOT_NETWORK);
assertThat(service.getLatch().await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
assertThat(service.getConnectedHotspotNetwork()).isEqualTo(HOTSPOT_NETWORK);
}
@Test
public void disconnectHotspotNetwork() throws RemoteException, InterruptedException {
FakeSharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
service.initializeLatch();
binder.disconnectHotspotNetwork(HOTSPOT_NETWORK);
assertThat(service.getLatch().await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
assertThat(service.getDisconnectedHotspotNetwork()).isEqualTo(HOTSPOT_NETWORK);
}
@Test
public void connectKnownNetwork() throws RemoteException , InterruptedException {
FakeSharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
service.initializeLatch();
binder.connectKnownNetwork(KNOWN_NETWORK);
assertThat(service.getLatch().await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
assertThat(service.getConnectedKnownNetwork()).isEqualTo(KNOWN_NETWORK);
}
@Test
public void forgetKnownNetwork() throws RemoteException, InterruptedException {
FakeSharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
service.initializeLatch();
binder.forgetKnownNetwork(KNOWN_NETWORK);
assertThat(service.getLatch().await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
assertThat(service.getForgottenKnownNetwork()).isEqualTo(KNOWN_NETWORK);
}
@Test
public void registerCallback() throws RemoteException, InterruptedException {
SharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
when(mCallback.asBinder()).thenReturn(mBinder);
when(mContext.getPackageName()).thenReturn("android.net.wifi.nonupdatable.test");
SharedConnectivitySettingsState state = buildSettingsState();
CountDownLatch latch = new CountDownLatch(1);
service.setCountdownLatch(latch);
binder.registerCallback(mCallback);
assertThat(latch.await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
service.setHotspotNetworks(HOTSPOT_NETWORKS);
service.setKnownNetworks(KNOWN_NETWORKS);
service.setSettingsState(state);
service.updateHotspotNetworkConnectionStatus(HOTSPOT_NETWORK_CONNECTION_STATUS);
service.updateKnownNetworkConnectionStatus(KNOWN_NETWORK_CONNECTION_STATUS);
verify(mCallback).onHotspotNetworksUpdated(HOTSPOT_NETWORKS);
verify(mCallback).onKnownNetworksUpdated(KNOWN_NETWORKS);
verify(mCallback).onSharedConnectivitySettingsChanged(state);
verify(mCallback).onHotspotNetworkConnectionStatusChanged(
HOTSPOT_NETWORK_CONNECTION_STATUS);
verify(mCallback).onKnownNetworkConnectionStatusChanged(KNOWN_NETWORK_CONNECTION_STATUS);
}
@Test
public void unregisterCallback() throws RemoteException, InterruptedException {
SharedConnectivityService service = createService();
ISharedConnectivityService.Stub binder =
(ISharedConnectivityService.Stub) service.onBind(new Intent());
when(mCallback.asBinder()).thenReturn(mBinder);
when(mContext.getPackageName()).thenReturn("android.net.wifi.nonupdatable.test");
CountDownLatch latch = new CountDownLatch(1);
service.setCountdownLatch(latch);
binder.registerCallback(mCallback);
assertThat(latch.await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
latch = new CountDownLatch(1);
service.setCountdownLatch(latch);
binder.unregisterCallback(mCallback);
assertThat(latch.await(LATCH_TIMEOUT, TimeUnit.SECONDS)).isTrue();
service.setHotspotNetworks(HOTSPOT_NETWORKS);
service.setKnownNetworks(KNOWN_NETWORKS);
service.setSettingsState(buildSettingsState());
service.updateHotspotNetworkConnectionStatus(HOTSPOT_NETWORK_CONNECTION_STATUS);
service.updateKnownNetworkConnectionStatus(KNOWN_NETWORK_CONNECTION_STATUS);
verify(mCallback, never()).onHotspotNetworksUpdated(any());
verify(mCallback, never()).onKnownNetworksUpdated(any());
verify(mCallback, never()).onSharedConnectivitySettingsChanged(any());
verify(mCallback, never()).onHotspotNetworkConnectionStatusChanged(any());
verify(mCallback, never()).onKnownNetworkConnectionStatusChanged(any());
}
private FakeSharedConnectivityService createService() {
FakeSharedConnectivityService service = new FakeSharedConnectivityService();
service.attachBaseContext(mContext);
return service;