From 5d5830d2c6d169f5c3bb4784ed72f840cd12fb7b Mon Sep 17 00:00:00 2001 From: cyBerta Date: Fri, 10 Jan 2020 03:11:02 +0100 Subject: Don't change the wifi tethering state if a check fails with an exception, unit tests for TetheringStateManager, some minor refacorings related to that --- .../tethering/TetheringStateManagerTest.java | 279 +++++++++++++++++++++ 1 file changed, 279 insertions(+) create mode 100644 app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java (limited to 'app/src/test/java') diff --git a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java new file mode 100644 index 00000000..295714c3 --- /dev/null +++ b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java @@ -0,0 +1,279 @@ +/** + * Copyright (c) 2020 LEAP Encryption Access Project and contributers + * + * This program is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ +package se.leap.bitmaskclient.tethering; + +import android.content.Context; +import android.content.IntentFilter; + +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Answers; +import org.mockito.Mock; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.stubbing.Answer; +import org.powermock.api.mockito.PowerMockito; +import org.powermock.core.classloader.annotations.PrepareForTest; +import org.powermock.modules.junit4.PowerMockRunner; + +import java.net.NetworkInterface; +import java.net.SocketException; +import java.util.Arrays; +import java.util.Collections; +import java.util.Enumeration; + +import se.leap.bitmaskclient.utils.Cmd; + +import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.assertFalse; +import static org.mockito.ArgumentMatchers.any; +import static org.mockito.ArgumentMatchers.anyString; +import static org.mockito.Mockito.mock; +import static org.powermock.api.mockito.PowerMockito.mockStatic; +import static org.powermock.api.mockito.PowerMockito.when; + + +@RunWith(PowerMockRunner.class) +@PrepareForTest({WifiManagerWrapper.class, TetheringStateManager.class, Cmd.class, NetworkInterface.class}) +public class TetheringStateManagerTest { + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + Context mockContext; + + @Mock(answer = Answers.RETURNS_DEEP_STUBS) + IntentFilter intentFilter; + + TetheringObservable observable; + + @Before + public void setup() throws Exception { + PowerMockito.whenNew(IntentFilter.class).withArguments(anyString()).thenReturn(intentFilter); + PowerMockito.whenNew(IntentFilter.class).withNoArguments().thenReturn(intentFilter); + observable = TetheringObservable.getInstance(); + + } + + @Test + public void updateUsbTetheringState_findsRndisX_returnsTrue() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(false); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + PowerMockito.mockStatic(NetworkInterface.class); + NetworkInterface mock1 = PowerMockito.mock(NetworkInterface.class); + when(mock1.isLoopback()).thenReturn(false); + when(mock1.getName()).thenReturn("eth0"); + NetworkInterface mock2 = PowerMockito.mock(NetworkInterface.class); + when(mock2.isLoopback()).thenReturn(false); + when(mock2.getName()).thenReturn("rndis0"); + + NetworkInterface[] networkInterfaces = new NetworkInterface[2]; + networkInterfaces[0] = mock1; + networkInterfaces[1] = mock2; + + PowerMockito.when(NetworkInterface.getNetworkInterfaces()).then(new Answer>() { + @Override + public Enumeration answer(InvocationOnMock invocation) throws Throwable { + return Collections.enumeration(Arrays.asList(networkInterfaces)); + } + }); + + TetheringObservable.setUsbTethering(false); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertTrue(observable.isUsbTetheringEnabled()); + } + + @Test + public void updateUsbTetheringState_doesntFindRndisX_returnsFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(false); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + PowerMockito.mockStatic(NetworkInterface.class); + NetworkInterface mock1 = PowerMockito.mock(NetworkInterface.class); + when(mock1.isLoopback()).thenReturn(false); + when(mock1.getName()).thenReturn("eth0"); + NetworkInterface mock2 = PowerMockito.mock(NetworkInterface.class); + when(mock2.isLoopback()).thenReturn(false); + when(mock2.getName()).thenReturn("wifi0"); + + NetworkInterface[] networkInterfaces = new NetworkInterface[2]; + networkInterfaces[0] = mock1; + networkInterfaces[1] = mock2; + + PowerMockito.when(NetworkInterface.getNetworkInterfaces()).then(new Answer>() { + @Override + public Enumeration answer(InvocationOnMock invocation) throws Throwable { + return Collections.enumeration(Arrays.asList(networkInterfaces)); + } + }); + + TetheringObservable.setUsbTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isUsbTetheringEnabled()); + } + + @Test + public void updateUsbTetheringState_ThrowsException_returnsFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(false); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + PowerMockito.mockStatic(NetworkInterface.class); + PowerMockito.when(NetworkInterface.getNetworkInterfaces()).thenThrow(new SocketException()); + + TetheringObservable.setUsbTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isUsbTetheringEnabled()); + } + + @Test + public void updateBluetoothTetheringState_btDeviceFound_returnTrue() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + mockStatic(Cmd.class); + PowerMockito.when(Cmd.runBlockingCmd(any(), any(StringBuilder.class))).then(new Answer() { + @Override + public Integer answer(InvocationOnMock invocation) throws Throwable { + StringBuilder logStringBuilder = invocation.getArgument(1); + logStringBuilder.append("bt-pan device found"); + return 0; + } + }); + + TetheringObservable.setBluetoothTethering(false); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertTrue(observable.isBluetoothTetheringEnabled()); + } + + + @Test + public void updateBluetoothTetheringState_btPanDeviceNotFound_returnFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + mockStatic(Cmd.class); + PowerMockito.when(Cmd.runBlockingCmd(any(), any(StringBuilder.class))).then(new Answer() { + @Override + public Integer answer(InvocationOnMock invocation) throws Throwable { + StringBuilder logStringBuilder = invocation.getArgument(1); + logStringBuilder.append("bt-pan device not found"); + return 1; + } + }); + + TetheringObservable.setBluetoothTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isBluetoothTetheringEnabled()); + } + + @Test + public void updateBluetoothTetheringState_ThrowsException_returnsFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + mockStatic(Cmd.class); + PowerMockito.when(Cmd.runBlockingCmd(any(), any(StringBuilder.class))). + thenThrow(new SecurityException("Creation of subprocess is not allowed")); + + TetheringObservable.setBluetoothTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isBluetoothTetheringEnabled()); + } + + @Test + public void updateBluetoothTetheringState_WifiManagerWrapperThrowsException_hasNoInfluenceOnResult() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenThrow(new NoSuchMethodException()); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + mockStatic(Cmd.class); + PowerMockito.when(Cmd.runBlockingCmd(any(), any(StringBuilder.class))).then(new Answer() { + @Override + public Integer answer(InvocationOnMock invocation) throws Throwable { + StringBuilder logStringBuilder = invocation.getArgument(1); + logStringBuilder.append("bt-pan device found"); + return 0; + } + }); + + TetheringObservable.setBluetoothTethering(false); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertTrue(observable.isBluetoothTetheringEnabled()); + } + + @Test + public void updateWifiTetheringState_ignoreFailingWifiAPReflection_keepsOldValueTrue() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenThrow(new NoSuchMethodException()); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + TetheringObservable.setWifiTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertTrue(observable.isWifiTetheringEnabled()); + } + + @Test + public void updateWifiTetheringState_ignoreFailingWifiAPReflection_keepsOldValueFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenThrow(new NoSuchMethodException()); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + TetheringObservable.setWifiTethering(false); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isWifiTetheringEnabled()); + } + + @Test + public void updateWifiTetheringState_WifiApReflectionWithoutException_changeValueToTrue() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + TetheringObservable.setWifiTethering(false); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertTrue(observable.isWifiTetheringEnabled()); + } + + @Test + public void updateWifiTetheringState_WifiApReflectionWithoutException_changeValueToFalse() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(false); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + TetheringObservable.setWifiTethering(true); + TetheringStateManager.getInstance().init(mockContext); + TetheringStateManager manager = TetheringStateManager.getInstance(); + assertFalse(observable.isWifiTetheringEnabled()); + } + + +} \ No newline at end of file -- cgit v1.2.3 From 7a42047640daef05f5771d8cb812a03ee14bbec6 Mon Sep 17 00:00:00 2001 From: cyberta Date: Wed, 29 Jan 2020 12:23:48 -0600 Subject: adapt tests --- .../tethering/TetheringStateManagerTest.java | 19 ++++++++++++++----- 1 file changed, 14 insertions(+), 5 deletions(-) (limited to 'app/src/test/java') diff --git a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java index 295714c3..85352c53 100644 --- a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java +++ b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java @@ -39,6 +39,7 @@ import java.util.Enumeration; import se.leap.bitmaskclient.utils.Cmd; import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.mockito.ArgumentMatchers.any; import static org.mockito.ArgumentMatchers.anyString; @@ -57,7 +58,7 @@ public class TetheringStateManagerTest { @Mock(answer = Answers.RETURNS_DEEP_STUBS) IntentFilter intentFilter; - TetheringObservable observable; + private TetheringObservable observable; @Before public void setup() throws Exception { @@ -233,7 +234,7 @@ public class TetheringStateManagerTest { when(mockWrapper.isWifiAPEnabled()).thenThrow(new NoSuchMethodException()); PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); - TetheringObservable.setWifiTethering(true); + TetheringObservable.setWifiTethering(true, "192.168.43.0/24", "wlan0"); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertTrue(observable.isWifiTetheringEnabled()); @@ -245,7 +246,7 @@ public class TetheringStateManagerTest { when(mockWrapper.isWifiAPEnabled()).thenThrow(new NoSuchMethodException()); PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); - TetheringObservable.setWifiTethering(false); + TetheringObservable.setWifiTethering(false, "", ""); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertFalse(observable.isWifiTetheringEnabled()); @@ -257,7 +258,7 @@ public class TetheringStateManagerTest { when(mockWrapper.isWifiAPEnabled()).thenReturn(true); PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); - TetheringObservable.setWifiTethering(false); + TetheringObservable.setWifiTethering(false, "", ""); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertTrue(observable.isWifiTetheringEnabled()); @@ -269,11 +270,19 @@ public class TetheringStateManagerTest { when(mockWrapper.isWifiAPEnabled()).thenReturn(false); PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); - TetheringObservable.setWifiTethering(true); + TetheringObservable.setWifiTethering(true, "", ""); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertFalse(observable.isWifiTetheringEnabled()); } + @Test + public void testGetWifiAddressRange() { + mockStatic(TetheringStateManager.class); + PowerMockito.when(TetheringStateManager.getWifiInterfaceAddress()).thenReturn("192.168.40.217/24"); + PowerMockito.when(TetheringStateManager.getInstance()).thenCallRealMethod(); + PowerMockito.when(TetheringStateManager.getWifiAddressRange()).thenCallRealMethod(); + assertEquals("192.168.40.0/24", TetheringStateManager.getWifiAddressRange()); + } } \ No newline at end of file -- cgit v1.2.3 From 3c130ce5f2741d4bc1c521507ab118a3006ec634 Mon Sep 17 00:00:00 2001 From: cyberta Date: Thu, 30 Jan 2020 22:48:35 -0600 Subject: adapt and extend tests --- .../tethering/TetheringStateManagerTest.java | 51 ++++++++++++++++++---- 1 file changed, 42 insertions(+), 9 deletions(-) (limited to 'app/src/test/java') diff --git a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java index 85352c53..2e6292a6 100644 --- a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java +++ b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java @@ -93,7 +93,7 @@ public class TetheringStateManagerTest { } }); - TetheringObservable.setUsbTethering(false); + TetheringObservable.setUsbTethering(false, "192.168.42.0/24", "rndis0"); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertTrue(observable.isUsbTetheringEnabled()); @@ -124,7 +124,7 @@ public class TetheringStateManagerTest { } }); - TetheringObservable.setUsbTethering(true); + TetheringObservable.setUsbTethering(true, "192.168.42.0/24", "rndis0"); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertFalse(observable.isUsbTetheringEnabled()); @@ -139,7 +139,7 @@ public class TetheringStateManagerTest { PowerMockito.mockStatic(NetworkInterface.class); PowerMockito.when(NetworkInterface.getNetworkInterfaces()).thenThrow(new SocketException()); - TetheringObservable.setUsbTethering(true); + TetheringObservable.setUsbTethering(true, "192.168.42.0/24", "rndis0"); TetheringStateManager.getInstance().init(mockContext); TetheringStateManager manager = TetheringStateManager.getInstance(); assertFalse(observable.isUsbTetheringEnabled()); @@ -277,12 +277,45 @@ public class TetheringStateManagerTest { } @Test - public void testGetWifiAddressRange() { - mockStatic(TetheringStateManager.class); - PowerMockito.when(TetheringStateManager.getWifiInterfaceAddress()).thenReturn("192.168.40.217/24"); - PowerMockito.when(TetheringStateManager.getInstance()).thenCallRealMethod(); - PowerMockito.when(TetheringStateManager.getWifiAddressRange()).thenCallRealMethod(); - assertEquals("192.168.40.0/24", TetheringStateManager.getWifiAddressRange()); + public void testGetWifiAddressRangee_keepsLastSeenAddressAndInterface() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + //WifiTethering was switched on + TetheringObservable.setWifiTethering(true, "192.168.40.0/24", "wlan0"); + + assertEquals("192.168.40.0/24", observable.getTetheringState().wifiAddress); + assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenWifiAddress); + assertEquals("wlan0", observable.getTetheringState().wifiInterface); + assertEquals("wlan0", observable.getTetheringState().lastSeenWifiInterface); + //Wifi tethering was switched off + TetheringObservable.setWifiTethering(true, "", ""); + assertEquals("", observable.getTetheringState().wifiAddress); + assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenWifiAddress); + assertEquals("", observable.getTetheringState().wifiInterface); + assertEquals("wlan0", observable.getTetheringState().lastSeenWifiInterface); + } + + @Test + public void testGetUsbAddressRange_keepsLastSeenAddressAndInterface() throws Exception { + WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); + when(mockWrapper.isWifiAPEnabled()).thenReturn(true); + PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); + + //WifiTethering was switched on + TetheringObservable.setWifiTethering(true, "192.168.40.0/24", "rndis0"); + + assertEquals("192.168.40.0/24", observable.getTetheringState().usbAddress); + assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenUsbAddress); + assertEquals("rndis0", observable.getTetheringState().usbInterface); + assertEquals("rndis0", observable.getTetheringState().lastSeenUsbAddress); + //Wifi tethering was switched off + TetheringObservable.setWifiTethering(true, "", ""); + assertEquals("", observable.getTetheringState().usbAddress); + assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenUsbAddress); + assertEquals("", observable.getTetheringState().usbInterface); } + } \ No newline at end of file -- cgit v1.2.3 From c0fc9a2daa2ca65fe14cf79445b70cc369aca918 Mon Sep 17 00:00:00 2001 From: cyberta Date: Fri, 31 Jan 2020 11:05:26 -0600 Subject: fix test --- .../bitmaskclient/tethering/TetheringStateManagerTest.java | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) (limited to 'app/src/test/java') diff --git a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java index 2e6292a6..7aeaf4b9 100644 --- a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java +++ b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java @@ -303,18 +303,18 @@ public class TetheringStateManagerTest { when(mockWrapper.isWifiAPEnabled()).thenReturn(true); PowerMockito.whenNew(WifiManagerWrapper.class).withAnyArguments().thenReturn(mockWrapper); - //WifiTethering was switched on - TetheringObservable.setWifiTethering(true, "192.168.40.0/24", "rndis0"); - + //UsbTethering was switched on + TetheringObservable.setUsbTethering(true, "192.168.40.0/24", "rndis0"); assertEquals("192.168.40.0/24", observable.getTetheringState().usbAddress); assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenUsbAddress); assertEquals("rndis0", observable.getTetheringState().usbInterface); - assertEquals("rndis0", observable.getTetheringState().lastSeenUsbAddress); - //Wifi tethering was switched off - TetheringObservable.setWifiTethering(true, "", ""); + assertEquals("rndis0", observable.getTetheringState().lastSeenUsbInterface); + //UsbTethering tethering was switched off + TetheringObservable.setUsbTethering(true, "", ""); assertEquals("", observable.getTetheringState().usbAddress); assertEquals("192.168.40.0/24", observable.getTetheringState().lastSeenUsbAddress); assertEquals("", observable.getTetheringState().usbInterface); + assertEquals("rndis0", observable.getTetheringState().lastSeenUsbInterface); } -- cgit v1.2.3 From b8ba423d997f5dbb2541b4f4542a2b6b30400485 Mon Sep 17 00:00:00 2001 From: cyberta Date: Sat, 1 Feb 2020 00:22:31 -0600 Subject: comment out tests for commented out bluetooth tethering code --- .../java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java | 2 ++ 1 file changed, 2 insertions(+) (limited to 'app/src/test/java') diff --git a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java index 7aeaf4b9..b3ab75ba 100644 --- a/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java +++ b/app/src/test/java/se/leap/bitmaskclient/tethering/TetheringStateManagerTest.java @@ -145,6 +145,7 @@ public class TetheringStateManagerTest { assertFalse(observable.isUsbTetheringEnabled()); } +/* //TODO enable these tests as soon as bluetooth tethering has been enabled again @Test public void updateBluetoothTetheringState_btDeviceFound_returnTrue() throws Exception { WifiManagerWrapper mockWrapper = mock(WifiManagerWrapper.class); @@ -227,6 +228,7 @@ public class TetheringStateManagerTest { TetheringStateManager manager = TetheringStateManager.getInstance(); assertTrue(observable.isBluetoothTetheringEnabled()); } + */ @Test public void updateWifiTetheringState_ignoreFailingWifiAPReflection_keepsOldValueTrue() throws Exception { -- cgit v1.2.3