tests/carservice_unit_test/src/com/android/car/vms/VmsBrokerServiceTest.java

/*
 * Copyright (C) 2020 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.car.vms;

import static com.google.common.truth.Truth.assertThat;

import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import static org.testng.Assert.assertThrows;

import static java.util.Arrays.asList;
import static java.util.Collections.emptySet;

import android.car.vms.IVmsClientCallback;
import android.car.vms.VmsAssociatedLayer;
import android.car.vms.VmsAvailableLayers;
import android.car.vms.VmsLayer;
import android.car.vms.VmsLayerDependency;
import android.car.vms.VmsProviderInfo;
import android.car.vms.VmsRegistrationInfo;
import android.car.vms.VmsSubscriptionState;
import android.content.Context;
import android.content.pm.PackageManager;
import android.os.Binder;
import android.os.IBinder;
import android.os.RemoteException;
import android.os.UserHandle;

import androidx.test.filters.SmallTest;

import com.android.car.stats.CarStatsService;
import com.android.car.stats.VmsClientLogger;

import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnitRunner;

import java.util.Arrays;
import java.util.HashSet;
import java.util.Set;

@RunWith(MockitoJUnitRunner.class)
@SmallTest
public class VmsBrokerServiceTest {
    private static final int USER_ID = 10;

    private static final String TEST_PACKAGE1 = "test.package1";
    private static final String TEST_PACKAGE2 = "test.package2";

    private static final int TEST_APP_ID1 = 12345;
    private static final int TEST_APP_ID2 = 54321;
    private static final int TEST_APP_UID1 = UserHandle.getUid(USER_ID, TEST_APP_ID1);
    private static final int TEST_APP_UID2 = UserHandle.getUid(USER_ID, TEST_APP_ID2);
    private static final int NO_SUBSCRIBERS_UID = -1;

    private static final VmsProviderInfo PROVIDER_INFO1 =
            new VmsProviderInfo(new byte[]{1, 2, 3, 4, 5});
    private static final VmsProviderInfo PROVIDER_INFO2 =
            new VmsProviderInfo(new byte[]{5, 4, 3, 2, 1});

    private static final VmsAvailableLayers DEFAULT_AVAILABLE_LAYERS =
            new VmsAvailableLayers(emptySet(), 0);
    private static final VmsSubscriptionState DEFAULT_SUBSCRIPTION_STATE =
            new VmsSubscriptionState(0, emptySet(), emptySet());

    private static final VmsLayer LAYER1 = new VmsLayer(1, 1, 1);
    private static final VmsLayer LAYER2 = new VmsLayer(2, 1, 1);
    private static final VmsLayer LAYER3 = new VmsLayer(3, 1, 1);

    private static final byte[] PAYLOAD = {1, 2, 3, 4, 5, 6, 7, 8};

    @Mock
    private Context mContext;
    @Mock
    private PackageManager mPackageManager;
    @Mock
    private CarStatsService mStatsService;

    @Mock
    private IVmsClientCallback mClientCallback1;
    @Mock
    private Binder mClientBinder1;
    @Mock
    private VmsClientLogger mClientLog1;

    @Mock
    private IVmsClientCallback mClientCallback2;
    @Mock
    private Binder mClientBinder2;
    @Mock
    private VmsClientLogger mClientLog2;

    @Mock
    private VmsClientLogger mNoSubscribersLog;


    private final IBinder mClientToken1 = new Binder();
    private final IBinder mClientToken2 = new Binder();

    private VmsNewBrokerService mBrokerService;
    private int mCallingAppUid;

    @Before
    public void setUp() throws Exception {
        when(mContext.getPackageManager()).thenReturn(mPackageManager);
        mBrokerService = new VmsNewBrokerService(mContext, mStatsService, () -> mCallingAppUid);

        when(mPackageManager.getNameForUid(TEST_APP_UID1)).thenReturn(TEST_PACKAGE1);
        when(mPackageManager.getNameForUid(TEST_APP_UID2)).thenReturn(TEST_PACKAGE2);

        when(mStatsService.getVmsClientLogger(TEST_APP_UID1)).thenReturn(mClientLog1);
        when(mStatsService.getVmsClientLogger(TEST_APP_UID2)).thenReturn(mClientLog2);
        when(mStatsService.getVmsClientLogger(NO_SUBSCRIBERS_UID)).thenReturn(mNoSubscribersLog);

        when(mClientCallback1.asBinder()).thenReturn(mClientBinder1);
        when(mClientCallback2.asBinder()).thenReturn(mClientBinder2);

        mCallingAppUid = TEST_APP_UID1;
    }

    @Test
    public void testRegister() {
        VmsRegistrationInfo registrationInfo =
                mBrokerService.registerClient(mClientToken1, mClientCallback1);

        verify(mClientLog1).logConnectionState(VmsClientLogger.ConnectionState.CONNECTED);
        assertThat(registrationInfo.getAvailableLayers()).isEqualTo(DEFAULT_AVAILABLE_LAYERS);
        assertThat(registrationInfo.getSubscriptionState()).isEqualTo(DEFAULT_SUBSCRIPTION_STATE);
    }

    @Test
    public void testRegister_TwoClients_OneProcess() {
        VmsRegistrationInfo registrationInfo =
                mBrokerService.registerClient(mClientToken1, mClientCallback1);
        VmsRegistrationInfo registrationInfo2 =
                mBrokerService.registerClient(mClientToken2, mClientCallback2);

        verify(mClientLog1, times(2))
                .logConnectionState(VmsClientLogger.ConnectionState.CONNECTED);
        assertThat(registrationInfo).isEqualTo(registrationInfo2);
    }

    @Test
    public void testRegister_TwoClients_TwoProcesses() {
        VmsRegistrationInfo registrationInfo =
                mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mCallingAppUid = TEST_APP_UID2;
        VmsRegistrationInfo registrationInfo2 =
                mBrokerService.registerClient(mClientToken2, mClientCallback2);

        verify(mClientLog1).logConnectionState(VmsClientLogger.ConnectionState.CONNECTED);
        verify(mClientLog2).logConnectionState(VmsClientLogger.ConnectionState.CONNECTED);
        assertThat(registrationInfo).isEqualTo(registrationInfo2);
    }

    @Test
    public void testRegister_ReceivesCurrentLayerAvailabilityAndSubscriptions() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)));
        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));

        VmsRegistrationInfo registrationInfo =
                mBrokerService.registerClient(mClientToken2, mClientCallback2);

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1,
                        asSet(providerId))),
                1);
        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345)))
        );
        VmsRegistrationInfo expectedRegistrationInfo =
                new VmsRegistrationInfo(expectedLayers, expectedSubscriptions);
        assertThat(registrationInfo).isEqualTo(expectedRegistrationInfo);
    }

    @Test
    public void testRegisterProvider_UnknownClient() {
        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.registerProvider(new Binder(), PROVIDER_INFO1));
    }

    @Test
    public void testRegisterProvider_SameIdForSameInfo() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThat(providerId).isEqualTo(providerId2);
    }

    @Test
    public void testRegisterProvider_SameIdForSameInfo_MultipleClients() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        assertThat(providerId).isEqualTo(providerId2);
    }

    @Test
    public void testRegisterProvider_DifferentIdForDifferentInfo() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        assertThat(providerId).isNotEqualTo(providerId2);
    }

    @Test
    public void testGetProviderInfo_UnknownClient() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.getProviderInfo(new Binder(), providerId));
    }

    @Test
    public void testGetProviderInfo_UnknownId() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        assertThat(mBrokerService.getProviderInfo(mClientToken1, 12345).getDescription()).isNull();
    }

    @Test
    public void testGetProviderInfo_RegisteredProvider() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThat(mBrokerService.getProviderInfo(mClientToken1, providerId))
                .isEqualTo(PROVIDER_INFO1);
    }

    @Test
    public void testSetSubscriptions_UnknownClient() {
        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.setSubscriptions(new Binder(), asList()));
    }

    @Test
    public void testSetSubscriptions() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_OverwriteSubscription() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                asSet(LAYER2),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_OverwriteSubscription_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER3, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1, LAYER3),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_OnUnregister_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_OnUnregister_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_OnDisconnect_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_RemoveSubscription_OnDisconnect_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }


    @Test
    public void testSetSubscriptions_MultipleLayers() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1, LAYER2),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayers_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER3, emptySet())
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                asSet(LAYER1, LAYER2, LAYER3),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345, 54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_OverwriteSubscription() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_OverwriteSubscription_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER3, asSet(98765))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(
                        new VmsAssociatedLayer(LAYER1, asSet(12345)),
                        new VmsAssociatedLayer(LAYER3, asSet(98765))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_OverwriteSubscription_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(98765))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345, 98765))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_OverwriteSubscription_MultipleClients_SameLayerAndProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_MultipleClients_SameLayerAndProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnUnregister_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnUnregister_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnUnregister_MultipleClients_SameLayerAndProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnDisconnect_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnDisconnect_MultipleClients_SameLayer()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndProvider_RemoveSubscription_OnDisconnect_MultipleClients_SameLayerAndProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndMultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345, 54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345, 54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerAndMultipleProviders_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345, 54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER3, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                asSet(LAYER1, LAYER3),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345, 54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_OverwriteSubscription()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                asSet(LAYER2),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_OverwriteSubscription_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER3, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(54321))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1, LAYER3),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345, 54321))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_RemoveSubscription()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_RemoveSubscription_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_RemoveSubscription_OnUnregister_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.unregisterClient(mClientToken2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndProvider_RemoveSubscription_OnDisconnect_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        disconnectClient(mClientCallback2);

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                asSet(LAYER1),
                asSet(new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndMultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321)),
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                emptySet(),
                asSet(
                        new VmsAssociatedLayer(LAYER1, asSet(54321)),
                        new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_MultipleLayersAndMultipleProviders_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(54321))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER2, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                asSet(
                        new VmsAssociatedLayer(LAYER1, asSet(54321)),
                        new VmsAssociatedLayer(LAYER2, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerOnlySupersedesLayerAndProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerOnlySupersedesLayerAndProvider_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(1,
                asSet(LAYER1),
                emptySet());
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerOnlySupersedesLayerAndProvider_RemoveLayerSubscription()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet()),
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(2,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
    }

    @Test
    public void testSetSubscriptions_LayerOnlySupersedesLayerAndProvider_RemoveLayerSubscription_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(12345))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList());

        VmsSubscriptionState expectedSubscriptions = new VmsSubscriptionState(3,
                emptySet(),
                asSet(new VmsAssociatedLayer(LAYER1, asSet(12345))));
        verifySubscriptionState(mClientCallback1, expectedSubscriptions);
        verifySubscriptionState(mClientCallback2, expectedSubscriptions);
    }

    @Test
    public void testSetMonitoringEnabled_UnknownClient() {
        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.setMonitoringEnabled(new Binder(), true));
    }

    @Test
    public void testSetMonitoringEnabled_Enable_NoSubscriptionChange() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setMonitoringEnabled(mClientToken1, true);

        verify(mClientCallback1, never()).onSubscriptionStateChanged(any());
    }

    @Test
    public void testSetMonitoringEnabled_Disable_NoSubscriptionChange() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        mBrokerService.setMonitoringEnabled(mClientToken1, false);

        verify(mClientCallback1, never()).onSubscriptionStateChanged(any());
    }

    @Test
    public void testSetProviderOfferings_UnknownClient() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.setProviderOfferings(new Binder(), providerId, asList()));
    }

    @Test
    public void testSetProviderOfferings_UnknownProviderId() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);

        assertThrows(
                IllegalArgumentException.class,
                () -> mBrokerService.setProviderOfferings(mClientToken1, 12345, asList()));
    }

    @Test
    public void testSetProviderOfferings_OtherClientsProviderId() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        assertThrows(
                IllegalArgumentException.class,
                () -> mBrokerService.setProviderOfferings(mClientToken2, providerId, asList()));
    }

    @Test
    public void testSetProviderOfferings_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleClients_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleLayers_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1),
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleLayers_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleLayers_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_MultipleLayers_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_OverwriteOffering_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_OverwriteOffering_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_OverwriteOffering_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_OverwriteOffering_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList());

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList());

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList());

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList());

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnUnregister_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        // Register second client to verify layer availability after first client disconnects
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.unregisterClient(mClientToken1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnUnregister_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        // Register second client to verify layer availability after first client disconnects
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.unregisterClient(mClientToken1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(emptySet(), 3);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnUnregister_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.unregisterClient(mClientToken1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId2))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnUnregister_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        disconnectClient(mClientCallback1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnDisconnect_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        // Register second client to verify layer availability after first client disconnects
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        disconnectClient(mClientCallback1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnDisconnect_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        // Register second client to verify layer availability after first client disconnects
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        disconnectClient(mClientCallback1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(emptySet(), 3);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnDisconnect_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER1)
        ));
        disconnectClient(mClientCallback1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId, providerId2))),
                2);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId2))),
                3);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_RemoveOfferings_OnDisconnect_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        disconnectClient(mClientCallback1);

        VmsAvailableLayers expectedLayers1 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        VmsAvailableLayers expectedLayers2 = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers1);
        verifyLayerAvailability(mClientCallback2, expectedLayers2);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2),
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_MultipleDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_ChainedDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER2, asSet(LAYER3)),
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_ChainedDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_ChainedDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId2)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyMet_ChainedDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER1, asSet(providerId)),
                new VmsAssociatedLayer(LAYER2, asSet(providerId)),
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER2, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleProviders() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleClients() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2),
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_MultipleDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_ChainedDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER2, asSet(LAYER3)),
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_ChainedDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_ChainedDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyCircular_ChainedDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER3, asSet(LAYER1))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_SingleProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_MultipleDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3)),
                new VmsLayerDependency(LAYER2)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER2, asSet(providerId))),
                1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_MultipleDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3))
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER3, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_MultipleDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER3, asSet(providerId2))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_MultipleDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2, LAYER3))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER3)
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(asSet(
                new VmsAssociatedLayer(LAYER3, asSet(providerId))),
                2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_ChainedDependencies_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2)),
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 1);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_ChainedDependencies_MultipleProviders()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken1, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_ChainedDependencies_MultipleClients()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        int providerId2 = mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId2, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testSetProviderOfferings_DependencyUnmet_ChainedDependencies_MultipleClients_SingleProvider()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.registerClient(mClientToken2, mClientCallback2);
        mBrokerService.registerProvider(mClientToken2, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1, asSet(LAYER2))
        ));
        mBrokerService.setProviderOfferings(mClientToken2, providerId, asList(
                new VmsLayerDependency(LAYER2, asSet(LAYER3))
        ));

        VmsAvailableLayers expectedLayers = new VmsAvailableLayers(emptySet(), 2);
        verifyLayerAvailability(mClientCallback1, expectedLayers);
        verifyLayerAvailability(mClientCallback2, expectedLayers);
    }

    @Test
    public void testPublish_UnknownClient() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThrows(
                IllegalStateException.class,
                () -> mBrokerService.publish(new Binder(), providerId, LAYER1, PAYLOAD));
    }

    @Test
    public void testPublish_UnknownOffering() {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        assertThrows(
                IllegalArgumentException.class,
                () -> mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD));
    }

    @Test
    public void testPublish_NoSubscribers() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MonitorSubscriber_Enabled() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setMonitoringEnabled(mClientToken1, true);
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MonitorSubscriber_EnabledAndDisabled() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setMonitoringEnabled(mClientToken1, true);
        mBrokerService.setMonitoringEnabled(mClientToken1, false);
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerSubscriber() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerSubscriber_Unsubscribe() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList());
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerSubscriber_DifferentLayer() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER2, emptySet())
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MultipleLayerSubscribers() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1, times(2)).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MultipleLayerSubscribers_DifferentProcesses() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mCallingAppUid = TEST_APP_UID2;
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, emptySet())
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1).logPacketReceived(LAYER1, PAYLOAD.length);
        verify(mClientLog2).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerAndProviderSubscriber() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerAndProviderSubscriber_Unsubscribe() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.setSubscriptions(mClientToken1, asList());
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_LayerAndProviderSubscriber_DifferentProvider() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);
        int providerId2 = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO2);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId2))
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mNoSubscribersLog).logPacketDropped(LAYER1, PAYLOAD.length);
        verifyNoMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyNoMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MultipleLayerAndProviderSubscribers() throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1, times(2)).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    @Test
    public void testPublish_MultipleLayerAndProviderSubscribers_DifferentProcesses()
            throws Exception {
        mBrokerService.registerClient(mClientToken1, mClientCallback1);
        int providerId = mBrokerService.registerProvider(mClientToken1, PROVIDER_INFO1);

        mBrokerService.setProviderOfferings(mClientToken1, providerId, asList(
                new VmsLayerDependency(LAYER1)
        ));
        mCallingAppUid = TEST_APP_UID2;
        mBrokerService.registerClient(mClientToken2, mClientCallback2);

        mBrokerService.setSubscriptions(mClientToken1, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.setSubscriptions(mClientToken2, asList(
                new VmsAssociatedLayer(LAYER1, asSet(providerId))
        ));
        mBrokerService.publish(mClientToken1, providerId, LAYER1, PAYLOAD);

        verify(mClientLog1).logPacketSent(LAYER1, PAYLOAD.length);
        verify(mClientLog1).logPacketReceived(LAYER1, PAYLOAD.length);
        verify(mClientLog2).logPacketReceived(LAYER1, PAYLOAD.length);
        verifyMessageReceived(mClientCallback1, providerId, LAYER1, PAYLOAD);
        verifyMessageReceived(mClientCallback2, providerId, LAYER1, PAYLOAD);
    }

    private static void disconnectClient(IVmsClientCallback callback) throws Exception {
        ArgumentCaptor<IBinder.DeathRecipient> deathRecipient =
                ArgumentCaptor.forClass(IBinder.DeathRecipient.class);
        verify(callback.asBinder()).linkToDeath(deathRecipient.capture(), eq(0));
        deathRecipient.getValue().binderDied();
    }

    private static void verifyLayerAvailability(
            IVmsClientCallback callback,
            VmsAvailableLayers availableLayers) throws RemoteException {
        ArgumentCaptor<VmsAvailableLayers> availableLayersCaptor =
                ArgumentCaptor.forClass(VmsAvailableLayers.class);
        verify(callback, times(availableLayers.getSequence()))
                .onLayerAvailabilityChanged(availableLayersCaptor.capture());
        assertThat(availableLayersCaptor.getValue()).isEqualTo(availableLayers);
    }

    private static void verifySubscriptionState(
            IVmsClientCallback callback,
            VmsSubscriptionState subscriptionState) throws RemoteException {
        ArgumentCaptor<VmsSubscriptionState> subscriptionStateCaptor =
                ArgumentCaptor.forClass(VmsSubscriptionState.class);
        verify(callback, times(subscriptionState.getSequenceNumber()))
                .onSubscriptionStateChanged(subscriptionStateCaptor.capture());
        assertThat(subscriptionStateCaptor.getValue()).isEqualTo(subscriptionState);
    }

    private static void verifyNoMessageReceived(
            IVmsClientCallback callback,
            int providerId, VmsLayer layer, byte[] payload) throws RemoteException {
        verify(callback, never()).onMessageReceived(providerId, layer, payload);
    }

    private static void verifyMessageReceived(
            IVmsClientCallback callback,
            int providerId, VmsLayer layer, byte[] payload) throws RemoteException {
        verify(callback).onMessageReceived(providerId, layer, payload);
    }

    private static <T> Set<T> asSet(T... values) {
        return new HashSet<T>(Arrays.asList(values));
    }
}