1 files changed, 83 insertions, 0 deletions

diff --git a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
index c5b0f8a4c..bba9977cd 100644
--- a/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
+++ b/tests/wifitests/src/com/android/server/wifi/WifiServiceImplTest.java
@@ -16,21 +16,30 @@
 
 package com.android.server.wifi;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.when;
 
 import android.content.Context;
 import android.content.res.Resources;
+import android.os.Handler;
 import android.os.HandlerThread;
+import android.os.Looper;
+import android.os.Message;
+import android.os.Messenger;
 import android.os.test.TestLooper;
 import android.test.suitebuilder.annotation.SmallTest;
 
 import com.android.internal.util.AsyncChannel;
+import com.android.server.wifi.util.WifiAsyncChannel;
 
 import org.junit.Before;
 import org.junit.Test;
 import org.mockito.Mock;
 import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
 
 /**
  * Unit tests for {@link WifiServiceImpl}.
@@ -58,6 +67,60 @@ public class WifiServiceImplTest {
     @Mock WifiMulticastLockManager mWifiMulticastLockManager;
     @Mock WifiLastResortWatchdog mWifiLastResortWatchdog;
     @Mock WifiBackupRestore mWifiBackupRestore;
+    @Spy FakeWifiLog mLog;
+
+    private class WifiAsyncChannelTester {
+        private static final String TAG = "WifiAsyncChannelTester";
+        public static final int CHANNEL_STATE_FAILURE = -1;
+        public static final int CHANNEL_STATE_DISCONNECTED = 0;
+        public static final int CHANNEL_STATE_HALF_CONNECTED = 1;
+        public static final int CHANNEL_STATE_FULLY_CONNECTED = 2;
+
+        private int mState = CHANNEL_STATE_DISCONNECTED;
+        private WifiAsyncChannel mChannel;
+        private WifiLog mAsyncTestLog;
+
+        WifiAsyncChannelTester(WifiInjector wifiInjector) {
+            mAsyncTestLog = wifiInjector.makeLog(TAG);
+        }
+
+        public int getChannelState() {
+            return mState;
+        }
+
+        public void connect(final Looper looper, final Messenger messenger,
+                final Handler incomingMessageHandler) {
+            assertEquals("AsyncChannel must be in disconnected state",
+                    CHANNEL_STATE_DISCONNECTED, mState);
+            mChannel = new WifiAsyncChannel(TAG);
+            mChannel.setWifiLog(mLog);
+            Handler handler = new Handler(mLooper.getLooper()) {
+                @Override
+                public void handleMessage(Message msg) {
+                    switch (msg.what) {
+                        case AsyncChannel.CMD_CHANNEL_HALF_CONNECTED:
+                            if (msg.arg1 == AsyncChannel.STATUS_SUCCESSFUL) {
+                                mChannel.sendMessage(AsyncChannel.CMD_CHANNEL_FULL_CONNECTION);
+                                mState = CHANNEL_STATE_HALF_CONNECTED;
+                            } else {
+                                mState = CHANNEL_STATE_FAILURE;
+                            }
+                            break;
+                        case AsyncChannel.CMD_CHANNEL_FULLY_CONNECTED:
+                            mState = CHANNEL_STATE_FULLY_CONNECTED;
+                            break;
+                        case AsyncChannel.CMD_CHANNEL_DISCONNECTED:
+                            mState = CHANNEL_STATE_DISCONNECTED;
+                            break;
+                        default:
+                            incomingMessageHandler.handleMessage(msg);
+                            break;
+                    }
+                }
+            };
+            mChannel.connect(null, handler, messenger);
+        }
+    }
 
     @Before public void setUp() {
         MockitoAnnotations.initMocks(this);
@@ -67,12 +130,20 @@ public class WifiServiceImplTest {
         when(mWifiInjector.getWifiServiceHandlerThread()).thenReturn(mHandlerThread);
         when(mHandlerThread.getLooper()).thenReturn(mLooper.getLooper());
         when(mContext.getResources()).thenReturn(mResources);
+        WifiAsyncChannel wifiAsyncChannel = new WifiAsyncChannel("WifiServiceImplTest");
+        wifiAsyncChannel.setWifiLog(mLog);
+        when(mFrameworkFacade.makeWifiAsyncChannel(anyString())).thenReturn(wifiAsyncChannel);
         when(mWifiInjector.getFrameworkFacade()).thenReturn(mFrameworkFacade);
         when(mWifiInjector.getWifiLockManager()).thenReturn(mLockManager);
         when(mWifiInjector.getWifiMulticastLockManager()).thenReturn(mWifiMulticastLockManager);
         when(mWifiInjector.getWifiLastResortWatchdog()).thenReturn(mWifiLastResortWatchdog);
         when(mWifiInjector.getWifiBackupRestore()).thenReturn(mWifiBackupRestore);
+        when(mWifiInjector.makeLog(anyString())).thenReturn(mLog);
+        WifiTrafficPoller wifiTrafficPoller = new WifiTrafficPoller(mContext,
+                mLooper.getLooper(), "mockWlan");
+        when(mWifiInjector.getWifiTrafficPoller()).thenReturn(wifiTrafficPoller);
         mWifiServiceImpl = new WifiServiceImpl(mContext, mWifiInjector, mAsyncChannel);
+        mWifiServiceImpl.setWifiHandlerLogForTest(mLog);
     }
 
     @Test
@@ -80,4 +151,16 @@ public class WifiServiceImplTest {
         assertFalse(mWifiServiceImpl.removeNetwork(-1));
     }
 
+    @Test
+    public void testAsyncChannelHalfConnected() {
+        WifiAsyncChannelTester channelTester = new WifiAsyncChannelTester(mWifiInjector);
+        Handler handler = mock(Handler.class);
+        TestLooper looper = new TestLooper();
+        channelTester.connect(looper.getLooper(), mWifiServiceImpl.getWifiServiceMessenger(),
+                handler);
+        mLooper.dispatchAll();
+        assertEquals("AsyncChannel must be half connected",
+                WifiAsyncChannelTester.CHANNEL_STATE_HALF_CONNECTED,
+                channelTester.getChannelState());
+    }
 }