path: root/tests/wifitests/src/com/android/server/wifi/p2p/SupplicantP2pIfaceCallbackTest.java

/*
 * Copyright (C) 2017 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.server.wifi.p2p;

import static org.junit.Assert.*;
import static org.mockito.Matchers.*;
import static org.mockito.Mockito.doAnswer;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;

import android.app.test.MockAnswerUtil.AnswerWithArguments;
import android.hardware.wifi.supplicant.V1_0.ISupplicantP2pIfaceCallback;
import android.hardware.wifi.supplicant.V1_0.ISupplicantP2pIfaceCallback.P2pStatusCode;
import android.hardware.wifi.supplicant.V1_0.WpsConfigMethods;
import android.net.wifi.WpsInfo;
import android.net.wifi.p2p.WifiP2pConfig;
import android.net.wifi.p2p.WifiP2pDevice;
import android.net.wifi.p2p.WifiP2pGroup;
import android.net.wifi.p2p.WifiP2pProvDiscEvent;
import android.net.wifi.p2p.nsd.WifiP2pServiceResponse;

import androidx.test.filters.SmallTest;

import com.android.server.wifi.WifiBaseTest;
import com.android.server.wifi.p2p.WifiP2pServiceImpl.P2pStatus;
import com.android.server.wifi.util.NativeUtil;

import org.junit.Before;
import org.junit.Test;
import org.mockito.ArgumentCaptor;
import org.mockito.MockitoAnnotations;

import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;

/**
 * Unit tests for SupplicantP2pIfaceCallback
 */
@SmallTest
public class SupplicantP2pIfaceCallbackTest extends WifiBaseTest {
    private static final String TAG = "SupplicantP2pIfaceCallbackTest";

    private String mIface = "test_p2p0";
    private String mGroupIface = "test_p2p-p2p0-3";
    private WifiP2pMonitor mMonitor;
    private SupplicantP2pIfaceCallback mDut;

    private byte[] mDeviceAddressInvalid1 = { 0x00 };
    private byte[] mDeviceAddressInvalid2 = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55, 0x66 };
    private byte[] mDeviceAddress1Bytes = { 0x00, 0x11, 0x22, 0x33, 0x44, 0x55 };
    private String mDeviceAddress1String = "00:11:22:33:44:55";
    private byte[] mDeviceAddress2Bytes = { 0x01, 0x12, 0x23, 0x34, 0x45, 0x56 };
    private String mDeviceAddress2String = "01:12:23:34:45:56";
    private byte[] mDeviceInfoBytes = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
    private static final byte[] DEVICE_ADDRESS = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05 };
    private static final int TEST_NETWORK_ID = 9;
    private static final int TEST_GROUP_FREQUENCY = 5400;

    private class SupplicantP2pIfaceCallbackSpy extends SupplicantP2pIfaceCallback {
        SupplicantP2pIfaceCallbackSpy(String iface, WifiP2pMonitor monitor) {
            super(iface, monitor);
        }
    }

    @Before
    public void setUp() throws Exception {
        MockitoAnnotations.initMocks(this);
        mMonitor = mock(WifiP2pMonitor.class);
        mDut = new SupplicantP2pIfaceCallbackSpy(mIface, mMonitor);
    }

    /**
     * Sunny day scenario for onDeviceFound call.
     */
    @Test
    public void testOnDeviceFound_success() throws Exception {
        byte[] fakePrimaryDeviceTypeBytes = { 0x00, 0x01, 0x02, -1, 0x04, 0x05, 0x06, 0x07 };
        String fakePrimaryDeviceTypeString = "1-02FF0405-1543";
        String fakeDeviceName = "test device name";
        short fakeConfigMethods = 0x1234;
        byte fakeCapabilities = 123;
        int fakeGroupCapabilities = 456;

        doAnswer(new AnswerWithArguments() {
            public void answer(String iface, WifiP2pDevice device) {
                // NOTE: mDeviceAddress1Bytes seems to be ignored by
                // legacy implementation of WifiP2pDevice.
                assertEquals(iface, mIface);
                assertEquals(device.deviceName, fakeDeviceName);
                assertEquals(device.primaryDeviceType, fakePrimaryDeviceTypeString);
                assertEquals(device.deviceCapability, fakeCapabilities);
                assertEquals(device.groupCapability, fakeGroupCapabilities);
                assertEquals(device.wpsConfigMethodsSupported, fakeConfigMethods);
                assertEquals(device.deviceAddress, mDeviceAddress2String);
                assertEquals(device.status, WifiP2pDevice.AVAILABLE);
            }
        })
        .when(mMonitor).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));

        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddress2Bytes,
                fakePrimaryDeviceTypeBytes,
                fakeDeviceName, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);

        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddress2Bytes,
                fakePrimaryDeviceTypeBytes,
                fakeDeviceName, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                null);

        // Make sure we issued a broadcast each time.
        verify(mMonitor, times(2)).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Sunny day scenario for onDeviceFound call with sign bit set in bytes.
     */
    @Test
    public void testOnDeviceFoundWithSignBitInDeviceInfoBytesSuccess() throws Exception {
        byte[] fakePrimaryDeviceTypeBytes = { 0x00, 0x01, 0x02, -1, 0x04, 0x05, 0x06, 0x07 };
        String fakePrimaryDeviceTypeString = "1-02FF0405-1543";
        String fakeDeviceName = "test device name";
        short fakeConfigMethods = 0x1234;
        byte fakeCapabilities = 123;
        int fakeGroupCapabilities = 456;
        byte[] fakeDevInfoBytes = { (byte) 0x80, 0x01, (byte) 0xC0, 0x03, (byte) 0xFF, 0x05 };

        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddress2Bytes,
                fakePrimaryDeviceTypeBytes,
                fakeDeviceName, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                fakeDevInfoBytes);

        ArgumentCaptor<WifiP2pDevice> deviceCaptor = ArgumentCaptor.forClass(WifiP2pDevice.class);
        verify(mMonitor).broadcastP2pDeviceFound(eq(mIface), deviceCaptor.capture());

        WifiP2pDevice device = deviceCaptor.getValue();
        assertEquals(fakeDeviceName, device.deviceName);
        assertEquals(fakePrimaryDeviceTypeString, device.primaryDeviceType);
        assertEquals(fakeCapabilities, device.deviceCapability);
        assertEquals(fakeGroupCapabilities, device.groupCapability);
        assertEquals(fakeConfigMethods, device.wpsConfigMethodsSupported);
        assertEquals(mDeviceAddress2String, device.deviceAddress);
        assertEquals(WifiP2pDevice.AVAILABLE, device.status);

        assertNotNull(device.wfdInfo);
        // WifiP2pWfdInfo.mDeviceInfo won't be returned as the raw value, skip it.
        assertEquals(((fakeDevInfoBytes[2] & 0xFF) << 8) + fakeDevInfoBytes[3],
                device.wfdInfo.getControlPort());
        assertEquals(((fakeDevInfoBytes[4] & 0xFF) << 8) + fakeDevInfoBytes[5],
                device.wfdInfo.getMaxThroughput());

        // Make sure we issued a broadcast each time.
        verify(mMonitor).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Failing scenarios for onDeviceFound call.
     */
    @Test
    public void testOnDeviceFound_invalidArguments() throws Exception {
        byte[] fakePrimaryDeviceTypeBytes = { 0x0, 0x01, 0x02, -1, 0x04, 0x05, 0x06, 0x07 };
        String fakePrimaryDeviceTypeString = "1-02FF0405-1543";
        String fakeDeviceName = "test device name";
        short fakeConfigMethods = 0x1234;
        byte fakeCapabilities = 123;
        int fakeGroupCapabilities = 456;

        mDut.onDeviceFound(
                mDeviceAddress2Bytes, null,
                fakePrimaryDeviceTypeBytes,
                fakeDeviceName, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);
        verify(mMonitor, never()).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));


        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddress2Bytes,
                null,
                fakeDeviceName, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);
        verify(mMonitor, never()).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));


        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddress2Bytes,
                fakePrimaryDeviceTypeBytes,
                null, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);
        verify(mMonitor, never()).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));


        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddressInvalid1,
                fakePrimaryDeviceTypeBytes,
                null, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);
        verify(mMonitor, never()).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));


        mDut.onDeviceFound(
                mDeviceAddress1Bytes, mDeviceAddressInvalid2,
                fakePrimaryDeviceTypeBytes,
                null, fakeConfigMethods,
                fakeCapabilities, fakeGroupCapabilities,
                mDeviceInfoBytes);
        verify(mMonitor, never()).broadcastP2pDeviceFound(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Sunny day scenario for onDeviceLost call.
     */
    @Test
    public void testOnDeviceLost_success() throws Exception {
        doAnswer(new AnswerWithArguments() {
            public void answer(String iface, WifiP2pDevice device) {
                assertEquals(iface, mIface);
                assertEquals(device.deviceAddress, mDeviceAddress1String);
                assertEquals(device.status, WifiP2pDevice.UNAVAILABLE);
            }
        })
        .when(mMonitor).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));

        mDut.onDeviceLost(mDeviceAddress1Bytes);

        // Make sure we issued a broadcast each time.
        verify(mMonitor, times(1)).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Failing scenarios for onDeviceLost call.
     */
    @Test
    public void testOnDeviceLost_invalidArguments() throws Exception {
        mDut.onDeviceLost(null);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));

        mDut.onDeviceLost(mDeviceAddressInvalid1);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));

        mDut.onDeviceLost(mDeviceAddressInvalid2);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Sunny day scenario for onGoNegotiationRequest call.
     */
    @Test
    public void testOnGoNegotiationRequest_success() throws Exception {
        HashSet<Integer> setups = new HashSet<Integer>();

        doAnswer(new AnswerWithArguments() {
            public void answer(String iface, WifiP2pConfig config) {
                assertEquals(iface, mIface);
                assertNotNull(config.wps);
                setups.add(config.wps.setup);
                assertEquals(config.deviceAddress, mDeviceAddress1String);
            }
        })
        .when(mMonitor).broadcastP2pGoNegotiationRequest(
                anyString(), any(WifiP2pConfig.class));

        mDut.onGoNegotiationRequest(mDeviceAddress1Bytes,
                (short)ISupplicantP2pIfaceCallback.WpsDevPasswordId.USER_SPECIFIED);
        assertTrue(setups.contains(WpsInfo.DISPLAY));

        mDut.onGoNegotiationRequest(mDeviceAddress1Bytes,
                (short)ISupplicantP2pIfaceCallback.WpsDevPasswordId.PUSHBUTTON);
        assertTrue(setups.contains(WpsInfo.PBC));

        mDut.onGoNegotiationRequest(mDeviceAddress1Bytes,
                (short)ISupplicantP2pIfaceCallback.WpsDevPasswordId.REGISTRAR_SPECIFIED);
        assertTrue(setups.contains(WpsInfo.KEYPAD));

        // Invalid should default to PBC
        setups.clear();
        mDut.onGoNegotiationRequest(mDeviceAddress1Bytes, (short)0xffff);
        assertTrue(setups.contains(WpsInfo.PBC));
    }

    /**
     * Failing scenarios for onGoNegotiationRequest call.
     */
    @Test
    public void testOnGoNegotiationRequest_invalidArguments() throws Exception {
        mDut.onGoNegotiationRequest(null, (short)0);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));

        mDut.onGoNegotiationRequest(mDeviceAddressInvalid1, (short)0);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));

        mDut.onGoNegotiationRequest(mDeviceAddressInvalid2, (short)0);
        verify(mMonitor, never()).broadcastP2pDeviceLost(
                anyString(), any(WifiP2pDevice.class));
    }

    /**
     * Sunny day scenario for onGroupStarted call.
     */
    @Test
    public void testOnGroupStarted_success() throws Exception {
        String fakeName = "group name";
        String fakePassphrase = "secret";
        ArrayList<Byte> fakeSsidBytesList = new ArrayList<Byte>() {{
            add((byte)0x30);
            add((byte)0x31);
            add((byte)0x32);
            add((byte)0x33);
        }};
        String fakeSsidString = "0123";
        HashSet<String> passwords = new HashSet<String>();

        doAnswer(new AnswerWithArguments() {
            public void answer(String iface, WifiP2pGroup group) {
                assertEquals(iface, mIface);
                assertNotNull(group.getOwner());
                assertEquals(group.getOwner().deviceAddress, mDeviceAddress1String);
                assertEquals(group.getNetworkId(), WifiP2pGroup.NETWORK_ID_PERSISTENT);
                passwords.add(group.getPassphrase());
                assertEquals(group.getInterface(), fakeName);
                assertEquals(group.getNetworkName(), fakeSsidString);
            }
        })
        .when(mMonitor).broadcastP2pGroupStarted(
                anyString(), any(WifiP2pGroup.class));

        mDut.onGroupStarted(
                fakeName, true, fakeSsidBytesList, 1, null, fakePassphrase,
                mDeviceAddress1Bytes, true);
        assertTrue(passwords.contains(fakePassphrase));

        mDut.onGroupStarted(
                fakeName, true, fakeSsidBytesList, 1, null, null,
                mDeviceAddress1Bytes, true);
        assertTrue(passwords.contains(null));

        verify(mMonitor, times(2)).broadcastP2pGroupStarted(
                anyString(), any(WifiP2pGroup.class));
    }

    /**
     * Failing scenarios for onGroupStarted call.
     */
    @Test
    public void testOnGroupStarted_invalidArguments() throws Exception {
        String fakeName = "group name";
        String fakePassphrase = "secret";
        ArrayList<Byte> fakeSsidBytesList = new ArrayList<Byte>() {{
            add((byte)0x30);
            add((byte)0x31);
            add((byte)0x32);
            add((byte)0x33);
        }};
        String fakeSsidString = "0123";

        mDut.onGroupStarted(
                null, true, fakeSsidBytesList, 1, null, fakePassphrase,
                mDeviceAddress1Bytes, true);
        verify(mMonitor, never()).broadcastP2pGroupStarted(
                anyString(), any(WifiP2pGroup.class));

        mDut.onGroupStarted(
                fakeName, true, null, 1, null, fakePassphrase,
                mDeviceAddress1Bytes, true);
        verify(mMonitor, never()).broadcastP2pGroupStarted(
                anyString(), any(WifiP2pGroup.class));

        mDut.onGroupStarted(
                fakeName, true, fakeSsidBytesList, 1, null, fakePassphrase,
                null, true);
        verify(mMonitor, never()).broadcastP2pGroupStarted(
                anyString(), any(WifiP2pGroup.class));
    }

    /**
     * Test provision discovery callback.
     */
    @Test
    public void testOnProvisionDiscoveryCompleted() throws Exception {
        byte[] p2pDeviceAddr = DEVICE_ADDRESS;
        boolean isRequest = false;
        byte status = ISupplicantP2pIfaceCallback.P2pProvDiscStatusCode.SUCCESS;
        short configMethods = WpsConfigMethods.DISPLAY;
        String generatedPin = "12345678";

        ArgumentCaptor<WifiP2pProvDiscEvent> discEventCaptor =
                ArgumentCaptor.forClass(WifiP2pProvDiscEvent.class);
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor).broadcastP2pProvisionDiscoveryEnterPin(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.ENTER_PIN, discEventCaptor.getValue().event);

        configMethods = WpsConfigMethods.KEYPAD;
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor).broadcastP2pProvisionDiscoveryShowPin(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.SHOW_PIN, discEventCaptor.getValue().event);
        assertEquals(generatedPin, discEventCaptor.getValue().pin);

        isRequest = true;
        configMethods = WpsConfigMethods.KEYPAD;
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor, times(2)).broadcastP2pProvisionDiscoveryEnterPin(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.ENTER_PIN, discEventCaptor.getValue().event);

        configMethods = WpsConfigMethods.DISPLAY;
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor, times(2)).broadcastP2pProvisionDiscoveryShowPin(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.SHOW_PIN, discEventCaptor.getValue().event);
        assertEquals(generatedPin, discEventCaptor.getValue().pin);

        isRequest = false;
        configMethods = WpsConfigMethods.PUSHBUTTON;
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor).broadcastP2pProvisionDiscoveryPbcResponse(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.PBC_RSP, discEventCaptor.getValue().event);

        isRequest = true;
        mDut.onProvisionDiscoveryCompleted(
                p2pDeviceAddr, isRequest, status, configMethods, generatedPin);
        verify(mMonitor).broadcastP2pProvisionDiscoveryPbcRequest(
                anyString(), discEventCaptor.capture());
        assertEquals(WifiP2pProvDiscEvent.PBC_REQ, discEventCaptor.getValue().event);
    }

    /**
     * Test staAuth with device address, should trigger ApStaConnected broadcast
     */
    @Test
    public void testStaAuth_success() {
        // Trigger onStaAuthorized callback, ensure wifimonitor broadcast is sent with WifiP2pDevice
        // using the p2pDeviceAddress
        ArgumentCaptor<WifiP2pDevice> p2pDeviceCaptor =
                ArgumentCaptor.forClass(WifiP2pDevice.class);
        mDut.onStaAuthorized(mDeviceAddress1Bytes, mDeviceAddress2Bytes);
        verify(mMonitor).broadcastP2pApStaConnected(any(String.class), p2pDeviceCaptor.capture());
        assertEquals(mDeviceAddress2String, p2pDeviceCaptor.getValue().deviceAddress);
    }

    /**
     * Test staAuth without device address, should trigger ApStaConnected broadcast using srcAddress
     */
    @Test
    public void testStaAuth_noDeviceAddress_success() {
        // Trigger onStaAuthorized callback, using a zero'd p2pDeviceAddress, ensure wifimonitor
        // broadcast is sent with WifiP2pDevice using the srcAddress
        ArgumentCaptor<WifiP2pDevice> p2pDeviceCaptor =
                ArgumentCaptor.forClass(WifiP2pDevice.class);
        mDut.onStaAuthorized(mDeviceAddress1Bytes, NativeUtil.ANY_MAC_BYTES);
        verify(mMonitor).broadcastP2pApStaConnected(any(String.class), p2pDeviceCaptor.capture());
        assertEquals(mDeviceAddress1String, p2pDeviceCaptor.getValue().deviceAddress);
    }

    // TLVS hex data encoded as a hex string.
    // Taken directly from an observed supplicant service response event
    private static final String SERV_DISC_RESP_TLVS = "1d00010100076578616d706c650b5f6166706f766572"
            + "746370c00c001001001e000101000b5f6166706f766572746370c00c000c01074578616d706c65c0273c"
            + "00010100096d797072696e746572045f697070c00c00100109747874766572733d311a70646c3d617070"
            + "6c69636174696f6e2f706f73747363726970741900010100045f697070c00c000c01094d795072696e74"
            + "6572c0275f000201000a757569643a36383539646564652d383537342d353961622d393333322d313233"
            + "3435363738393031313a3a75726e3a736368656d61732d75706e702d6f72673a736572766963653a436f"
            + "6e6e656374696f6e4d616e616765723a3159000201000a757569643a36383539646564652d383537342d"
            + "353961622d393333322d3132333435363738393031313a3a75726e3a736368656d61732d75706e702d6f"
            + "72673a736572766963653a41565472616e73706f72743a315a000201000a757569643a36383539646564"
            + "652d383537342d353961622d393333322d3132333435363738393031313a3a75726e3a736368656d6173"
            + "2d75706e702d6f72673a6465766963653a4d6564696152656e64657265723a313e000201000a75756964"
            + "3a36383539646564652d383537342d353961622d393333322d3132333435363738393031313a3a75706e"
            + "703a726f6f746465766963652d000201000a757569643a36383539646564652d383537342d353961622d"
            + "393333322d313233343536373839303131";

    /**
     * Pretty basic onServiceDiscoveryResponse callback test.
     * Mocks the callback event, passing some observed real data to it, and ensures that it returns
     * a non-null WifiP2pServiceResponse list.
     */
    @Test
    public void testOnServiceDiscoveryResponseCompleted_success() throws Exception {
        ArrayList<Byte> tlvs = NativeUtil.byteArrayToArrayList(hexStr2Bin(SERV_DISC_RESP_TLVS));
        ArgumentCaptor<List<WifiP2pServiceResponse>> respListCaptor =
                ArgumentCaptor.forClass(List.class);
        mDut.onServiceDiscoveryResponse(
                mDeviceAddress1Bytes,
                (short) 10 /* unused updateIndicator value */,
                tlvs);
        verify(mMonitor).broadcastP2pServiceDiscoveryResponse(anyString(),
                respListCaptor.capture());
        assertNotNull(respListCaptor.getValue());
    }

    /**
     * Test onFindStopped event should trigger P2pFindStopped broadcast.
     */
    @Test
    public void testOnFindStopped() {
        mDut.onFindStopped();
        verify(mMonitor).broadcastP2pFindStopped(eq(mIface));
    }

    /**
     * Test onGoNegotiationCompleted sunny case.
     */
    @Test
    public void testOnGoNegotiationCompletedSuccess() {
        mDut.onGoNegotiationCompleted(P2pStatusCode.SUCCESS);
        verify(mMonitor).broadcastP2pGoNegotiationSuccess(eq(mIface));
    }

    /**
     * Test onGoNegotiationCompleted failure cases.
     */
    @Test
    public void testOnGoNegotiationCompletedFailureUnavailable() {
        mDut.onGoNegotiationCompleted(P2pStatusCode.FAIL_INFO_CURRENTLY_UNAVAILABLE);
        verify(mMonitor).broadcastP2pGoNegotiationFailure(
                eq(mIface), eq(P2pStatus.INFORMATION_IS_CURRENTLY_UNAVAILABLE));
    }

    /**
     * Test onGroupFormationSuccess should trigger P2pGroupFormationSuccess broadcast.
     */
    @Test
    public void testOnGroupFormationSuccess() {
        mDut.onGroupFormationSuccess();
        verify(mMonitor).broadcastP2pGroupFormationSuccess(eq(mIface));
    }

    /**
     * Test onGroupFormationFailure should trigger P2pGroupFormationFailure broadcast.
     */
    @Test
    public void testOnGroupFormationFailure() {
        mDut.onGroupFormationFailure("failure-reason");
        verify(mMonitor).broadcastP2pGroupFormationFailure(eq(mIface), eq("failure-reason"));
    }

    /**
     * Test onGroupRemoved should trigger P2pGroupRemoved broadcast for Group Owner.
     */
    @Test
    public void testOnGroupRemovedForGroupOwner() {
        mDut.onGroupRemoved(mGroupIface, true);
        ArgumentCaptor<WifiP2pGroup> groupCaptor = ArgumentCaptor.forClass(WifiP2pGroup.class);
        verify(mMonitor).broadcastP2pGroupRemoved(eq(mIface), groupCaptor.capture());
        assertEquals(mGroupIface, groupCaptor.getValue().getInterface());
        assertEquals(true, groupCaptor.getValue().isGroupOwner());
    }

    /**
     * Test onGroupRemoved should trigger P2pGroupRemoved broadcast for Group Client.
     */
    @Test
    public void testOnGroupRemovedForGroupClient() {
        mDut.onGroupRemoved(mGroupIface, false);

        ArgumentCaptor<WifiP2pGroup> groupCaptor = ArgumentCaptor.forClass(WifiP2pGroup.class);
        verify(mMonitor).broadcastP2pGroupRemoved(eq(mIface), groupCaptor.capture());
        assertEquals(mGroupIface, groupCaptor.getValue().getInterface());
        assertEquals(false, groupCaptor.getValue().isGroupOwner());
    }

    /**
     * Test onInvitationReceived should trigger P2pInvitationReceived broadcast.
     */
    @Test
    public void testOnInvitationReceived() {
        mDut.onInvitationReceived(
                mDeviceAddress1Bytes,
                mDeviceAddress2Bytes,
                DEVICE_ADDRESS,
                TEST_NETWORK_ID,
                TEST_GROUP_FREQUENCY);

        ArgumentCaptor<WifiP2pGroup> groupCaptor = ArgumentCaptor.forClass(WifiP2pGroup.class);
        verify(mMonitor).broadcastP2pInvitationReceived(eq(mIface), groupCaptor.capture());

        WifiP2pGroup group = groupCaptor.getValue();
        assertEquals(TEST_NETWORK_ID, group.getNetworkId());
        assertEquals(mDeviceAddress2String, group.getOwner().deviceAddress);
    }

    /**
     * Test onInvitationResult should trigger P2pInvitationResult broadcast.
     */
    @Test
    public void testOnInvitationResult() {
        mDut.onInvitationResult(mDeviceAddress1Bytes, P2pStatusCode.SUCCESS);
        verify(mMonitor).broadcastP2pInvitationResult(eq(mIface), eq(P2pStatus.SUCCESS));
    }

    /**
     * Test onStaDeauthorized should trigger P2pApStaDisconnected broadcast.
     */
    @Test
    public void testOnStaDeauthorized() {
        mDut.onStaDeauthorized(mDeviceAddress1Bytes, mDeviceAddress2Bytes);

        ArgumentCaptor<WifiP2pDevice> p2pDeviceCaptor =
                ArgumentCaptor.forClass(WifiP2pDevice.class);
        verify(mMonitor).broadcastP2pApStaDisconnected(eq(mIface), p2pDeviceCaptor.capture());
        assertEquals(mDeviceAddress2String, p2pDeviceCaptor.getValue().deviceAddress);
    }
    /**
     * Converts hex string to byte array.
     *
     * @param hex hex string. if invalid, return null.
     * @return binary data.
     */
    private static byte[] hexStr2Bin(String hex) {
        int sz = hex.length() / 2;
        byte[] b = new byte[hex.length() / 2];
        for (int i = 0; i < sz; i++) {
            try {
                b[i] = (byte) Integer.parseInt(hex.substring(i * 2, i * 2 + 2), 16);
            } catch (Exception e) {
                return null;
            }
        }
        return b;
    }
}