1 /* 2 * Copyright (C) 2017 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.car; 18 19 import static org.junit.Assert.assertArrayEquals; 20 import static org.junit.Assert.assertEquals; 21 import static org.junit.Assert.assertNull; 22 23 import android.car.vms.VmsAssociatedLayer; 24 import android.car.vms.VmsAvailableLayers; 25 import android.car.vms.VmsLayer; 26 import android.hardware.automotive.vehicle.VmsAvailabilityStateIntegerValuesIndex; 27 import android.hardware.automotive.vehicle.VmsMessageType; 28 import android.util.Pair; 29 30 import androidx.test.ext.junit.runners.AndroidJUnit4; 31 import androidx.test.filters.MediumTest; 32 33 import org.junit.Test; 34 import org.junit.runner.RunWith; 35 36 import java.util.Arrays; 37 import java.util.Collections; 38 import java.util.HashSet; 39 import java.util.Set; 40 41 @RunWith(AndroidJUnit4.class) 42 @MediumTest 43 public class VmsSubscriberManagerTest extends MockedVmsTestBase { 44 private static final int PUBLISHER_ID = 17; 45 private static final int WRONG_PUBLISHER_ID = 26; 46 private static final Set<Integer> PUBLISHERS_LIST = Collections.singleton(PUBLISHER_ID); 47 48 private static final int SUBSCRIPTION_LAYER_ID = 2; 49 private static final int SUBSCRIPTION_LAYER_VERSION = 3; 50 private static final int MOCK_PUBLISHER_LAYER_SUBTYPE = 444; 51 private static final VmsLayer SUBSCRIPTION_LAYER = new VmsLayer(SUBSCRIPTION_LAYER_ID, 52 MOCK_PUBLISHER_LAYER_SUBTYPE, 53 SUBSCRIPTION_LAYER_VERSION); 54 private static final VmsAssociatedLayer SUBSCRIPTION_ASSOCIATED_LAYER = 55 new VmsAssociatedLayer(SUBSCRIPTION_LAYER, PUBLISHERS_LIST); 56 57 private static final int SUBSCRIPTION_DEPENDANT_LAYER_ID_1 = 4; 58 private static final int SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1 = 5; 59 private static final VmsLayer SUBSCRIPTION_DEPENDANT_LAYER_1 = 60 new VmsLayer(SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 61 MOCK_PUBLISHER_LAYER_SUBTYPE, 62 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1); 63 64 private static final VmsAssociatedLayer SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_1 = 65 new VmsAssociatedLayer(SUBSCRIPTION_DEPENDANT_LAYER_1, PUBLISHERS_LIST); 66 67 private static final int SUBSCRIPTION_DEPENDANT_LAYER_ID_2 = 6; 68 private static final int SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2 = 7; 69 private static final VmsLayer SUBSCRIPTION_DEPENDANT_LAYER_2 = 70 new VmsLayer(SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 71 MOCK_PUBLISHER_LAYER_SUBTYPE, 72 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2); 73 74 private static final VmsAssociatedLayer SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_2 = 75 new VmsAssociatedLayer(SUBSCRIPTION_DEPENDANT_LAYER_2, PUBLISHERS_LIST); 76 77 private static final int SUBSCRIPTION_UNSUPPORTED_LAYER_ID = 100; 78 private static final int SUBSCRIPTION_UNSUPPORTED_LAYER_VERSION = 200; 79 80 private static final byte[] PAYLOAD = {0xa, 0xb}; 81 82 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 83 @Test testSubscribe()84 public void testSubscribe() throws Exception { 85 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER); 86 87 getMockHalClient().sendMessage( 88 new int[]{ 89 VmsMessageType.DATA, 90 SUBSCRIPTION_LAYER_ID, 91 MOCK_PUBLISHER_LAYER_SUBTYPE, 92 SUBSCRIPTION_LAYER_VERSION, 93 PUBLISHER_ID 94 }, 95 PAYLOAD); 96 97 Pair<VmsLayer, byte[]> message = getMockSubscriberClient().receiveMessage(); 98 assertEquals(SUBSCRIPTION_LAYER, message.first); 99 assertArrayEquals(PAYLOAD, message.second); 100 } 101 102 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 103 @Test testSubscribeToPublisher()104 public void testSubscribeToPublisher() throws Exception { 105 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 106 107 getMockHalClient().sendMessage( 108 new int[]{ 109 VmsMessageType.DATA, 110 SUBSCRIPTION_LAYER_ID, 111 MOCK_PUBLISHER_LAYER_SUBTYPE, 112 SUBSCRIPTION_LAYER_VERSION, 113 WRONG_PUBLISHER_ID 114 }, 115 PAYLOAD); 116 117 assertNull(getMockSubscriberClient().receiveMessage()); 118 } 119 120 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 121 @Test testSubscribeFromPublisher()122 public void testSubscribeFromPublisher() throws Exception { 123 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 124 125 getMockHalClient().sendMessage( 126 new int[]{ 127 VmsMessageType.DATA, 128 SUBSCRIPTION_LAYER_ID, 129 MOCK_PUBLISHER_LAYER_SUBTYPE, 130 SUBSCRIPTION_LAYER_VERSION, 131 PUBLISHER_ID 132 }, 133 PAYLOAD); 134 135 Pair<VmsLayer, byte[]> message = getMockSubscriberClient().receiveMessage(); 136 assertEquals(SUBSCRIPTION_LAYER, message.first); 137 assertArrayEquals(PAYLOAD, message.second); 138 } 139 140 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 141 @Test testUnsubscribe()142 public void testUnsubscribe() throws Exception { 143 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER); 144 getSubscriberManager().unsubscribe(SUBSCRIPTION_LAYER); 145 146 getMockHalClient().sendMessage( 147 new int[]{ 148 VmsMessageType.DATA, 149 SUBSCRIPTION_LAYER_ID, 150 MOCK_PUBLISHER_LAYER_SUBTYPE, 151 SUBSCRIPTION_LAYER_VERSION, 152 PUBLISHER_ID 153 }, 154 PAYLOAD); 155 156 assertNull(getMockSubscriberClient().receiveMessage()); 157 } 158 159 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 160 @Test testSubscribeFromWrongPublisher()161 public void testSubscribeFromWrongPublisher() throws Exception { 162 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 163 164 getMockHalClient().sendMessage( 165 new int[]{ 166 VmsMessageType.DATA, 167 SUBSCRIPTION_LAYER_ID, 168 MOCK_PUBLISHER_LAYER_SUBTYPE, 169 SUBSCRIPTION_LAYER_VERSION, 170 WRONG_PUBLISHER_ID 171 }, 172 PAYLOAD); 173 174 assertNull(getMockSubscriberClient().receiveMessage()); 175 } 176 177 // Test injecting a value in the HAL and verifying it does not propagate to a subscriber. 178 @Test testUnsubscribeFromPublisher()179 public void testUnsubscribeFromPublisher() throws Exception { 180 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 181 getSubscriberManager().unsubscribe(SUBSCRIPTION_LAYER, PUBLISHER_ID); 182 183 getMockHalClient().sendMessage( 184 new int[]{ 185 VmsMessageType.DATA, 186 SUBSCRIPTION_LAYER_ID, 187 MOCK_PUBLISHER_LAYER_SUBTYPE, 188 SUBSCRIPTION_LAYER_VERSION, 189 PUBLISHER_ID 190 }, 191 PAYLOAD); 192 193 assertNull(getMockSubscriberClient().receiveMessage()); 194 } 195 196 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 197 @Test testSubscribeAll()198 public void testSubscribeAll() throws Exception { 199 getSubscriberManager().startMonitoring(); 200 201 getMockHalClient().sendMessage( 202 new int[]{ 203 VmsMessageType.DATA, 204 SUBSCRIPTION_LAYER_ID, 205 MOCK_PUBLISHER_LAYER_SUBTYPE, 206 SUBSCRIPTION_LAYER_VERSION, 207 PUBLISHER_ID 208 }, 209 PAYLOAD); 210 211 Pair<VmsLayer, byte[]> message = getMockSubscriberClient().receiveMessage(); 212 assertEquals(SUBSCRIPTION_LAYER, message.first); 213 assertArrayEquals(PAYLOAD, message.second); 214 } 215 216 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 217 @Test testSimpleAvailableLayers()218 public void testSimpleAvailableLayers() throws Exception { 219 // 220 // Offering: 221 // Layer | Dependency 222 // =============================== 223 // (2, 3, 444), [17] | {} 224 225 // Expected availability: 226 // {(2, 3, 444 [17])} 227 // 228 getMockHalClient().sendMessage( 229 VmsMessageType.OFFERING, 230 PUBLISHER_ID, 231 1, // Number of offered layers 232 233 SUBSCRIPTION_LAYER_ID, 234 MOCK_PUBLISHER_LAYER_SUBTYPE, 235 SUBSCRIPTION_LAYER_VERSION, 236 0 // number of dependencies for layer 237 ); 238 239 assertEquals( 240 Collections.singleton(SUBSCRIPTION_ASSOCIATED_LAYER), 241 getMockSubscriberClient().receiveLayerAvailability().getAssociatedLayers()); 242 } 243 244 // Test injecting a value in the HAL and verifying it propagates to a subscriber after it has 245 // subscribed to a layer. 246 @Test testSimpleAvailableLayersAfterSubscription()247 public void testSimpleAvailableLayersAfterSubscription() throws Exception { 248 getSubscriberManager().subscribe(SUBSCRIPTION_LAYER); 249 250 // 251 // Offering: 252 // Layer | Dependency 253 // =============================== 254 // (2, 3, 444), [17] | {} 255 256 // Expected availability: 257 // {(2, 3, 444 [17])} 258 // 259 getMockHalClient().sendMessage( 260 VmsMessageType.OFFERING, // MessageType 261 PUBLISHER_ID, 262 1, // Number of offered layers 263 264 SUBSCRIPTION_LAYER_ID, 265 MOCK_PUBLISHER_LAYER_SUBTYPE, 266 SUBSCRIPTION_LAYER_VERSION, 267 0 // number of dependencies for layer 268 ); 269 270 assertEquals( 271 Collections.singleton(SUBSCRIPTION_ASSOCIATED_LAYER), 272 getMockSubscriberClient().receiveLayerAvailability().getAssociatedLayers()); 273 } 274 275 // Test injecting a value in the HAL and verifying it does not propagates to a subscriber after 276 // it has cleared its callback. 277 @Test testSimpleAvailableLayersAfterClear()278 public void testSimpleAvailableLayersAfterClear() throws Exception { 279 getSubscriberManager().clearVmsSubscriberClientCallback(); 280 // 281 // Offering: 282 // Layer | Dependency 283 // =============================== 284 // (2, 3, 444), [17] | {} 285 286 // Expected availability: 287 // {(2, 3, 444 [17])} 288 // 289 getMockHalClient().sendMessage( 290 VmsMessageType.OFFERING, // MessageType 291 PUBLISHER_ID, 292 1, // Number of offered layers 293 294 SUBSCRIPTION_LAYER_ID, 295 SUBSCRIPTION_LAYER_VERSION, 296 MOCK_PUBLISHER_LAYER_SUBTYPE, 297 0 // number of dependencies for layer 298 ); 299 300 assertNull(getMockSubscriberClient().receiveLayerAvailability()); 301 } 302 303 // Test injecting a value in the HAL and verifying it propagates to a subscriber. 304 @Test testComplexAvailableLayers()305 public void testComplexAvailableLayers() throws Exception { 306 // 307 // Offering: 308 // Layer | Dependency 309 // ===================================== 310 // (2, 3, 444), [17] | {} 311 // (4, 5, 444), [17] | {(2, 3)} 312 // (6, 7, 444), [17] | {(2, 3), (4, 5)} 313 // (6, 7, 444), [17] | {(100, 200)} 314 315 // Expected availability: 316 // {(2, 3, 444 [17]), (4, 5, 444 [17]), (6, 7, 444 [17])} 317 // 318 319 getMockHalClient().sendMessage( 320 VmsMessageType.OFFERING, // MessageType 321 PUBLISHER_ID, 322 4, // Number of offered layers 323 324 SUBSCRIPTION_LAYER_ID, 325 MOCK_PUBLISHER_LAYER_SUBTYPE, 326 SUBSCRIPTION_LAYER_VERSION, 327 0, // number of dependencies for layer 328 329 SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 330 MOCK_PUBLISHER_LAYER_SUBTYPE, 331 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1, 332 1, // number of dependencies for layer 333 SUBSCRIPTION_LAYER_ID, 334 MOCK_PUBLISHER_LAYER_SUBTYPE, 335 SUBSCRIPTION_LAYER_VERSION, 336 337 SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 338 MOCK_PUBLISHER_LAYER_SUBTYPE, 339 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2, 340 2, // number of dependencies for layer 341 SUBSCRIPTION_LAYER_ID, 342 MOCK_PUBLISHER_LAYER_SUBTYPE, 343 SUBSCRIPTION_LAYER_VERSION, 344 SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 345 MOCK_PUBLISHER_LAYER_SUBTYPE, 346 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1, 347 348 SUBSCRIPTION_DEPENDANT_LAYER_ID_2, 349 MOCK_PUBLISHER_LAYER_SUBTYPE, 350 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_2, 351 1, // number of dependencies for layer 352 SUBSCRIPTION_UNSUPPORTED_LAYER_ID, 353 MOCK_PUBLISHER_LAYER_SUBTYPE, 354 SUBSCRIPTION_UNSUPPORTED_LAYER_VERSION 355 ); 356 357 Set<VmsAssociatedLayer> associatedLayers = 358 new HashSet<>(Arrays.asList( 359 SUBSCRIPTION_ASSOCIATED_LAYER, 360 SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_1, 361 SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_2 362 )); 363 364 // Verify applications API. 365 VmsAvailableLayers availableLayers = getMockSubscriberClient().receiveLayerAvailability(); 366 assertEquals(associatedLayers, availableLayers.getAssociatedLayers()); 367 assertEquals(1, availableLayers.getSequence()); 368 369 // Verify HAL API. 370 int[] values = getMockHalClient().receiveMessage().value.int32Values; 371 int messageType = values[VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE]; 372 int sequenceNumber = values[VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER]; 373 int numberLayers = 374 values[VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS]; 375 376 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 377 assertEquals(1, sequenceNumber); 378 assertEquals(3, numberLayers); 379 } 380 381 // Test injecting a value in the HAL twice the sequence for availability is incremented. 382 @Test testDoubleOfferingAvailableLayers()383 public void testDoubleOfferingAvailableLayers() throws Exception { 384 // 385 // Offering: 386 // Layer | Dependency 387 // =============================== 388 // (2, 3, 444), [17] | {} 389 390 // Expected availability: 391 // {(2, 3, 444 [17])} 392 // 393 int[] offeringMessage = { 394 VmsMessageType.OFFERING, // MessageType 395 PUBLISHER_ID, 396 1, // Number of offered layers 397 398 SUBSCRIPTION_LAYER_ID, 399 MOCK_PUBLISHER_LAYER_SUBTYPE, 400 SUBSCRIPTION_LAYER_VERSION, 401 0 // number of dependencies for layer 402 }; 403 404 // Inject first offer. 405 getMockHalClient().sendMessage(offeringMessage); 406 407 // Verify applications API. 408 VmsAvailableLayers availableLayers = getMockSubscriberClient().receiveLayerAvailability(); 409 assertEquals( 410 Collections.singleton(SUBSCRIPTION_ASSOCIATED_LAYER), 411 availableLayers.getAssociatedLayers()); 412 assertEquals(1, availableLayers.getSequence()); 413 414 // Verify HAL API. 415 int[] values = getMockHalClient().receiveMessage().value.int32Values; 416 int messageType = values[VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE]; 417 int sequenceNumber = values[VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER]; 418 int numberLayers = 419 values[VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS]; 420 421 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 422 assertEquals(1, sequenceNumber); 423 assertEquals(1, numberLayers); 424 425 int[] offeringMessage2 = { 426 VmsMessageType.OFFERING, // MessageType 427 PUBLISHER_ID, 428 2, // Number of offered layers 429 430 SUBSCRIPTION_LAYER_ID, 431 MOCK_PUBLISHER_LAYER_SUBTYPE, 432 SUBSCRIPTION_LAYER_VERSION, 433 0, // number of dependencies for layer 434 435 SUBSCRIPTION_DEPENDANT_LAYER_ID_1, 436 MOCK_PUBLISHER_LAYER_SUBTYPE, 437 SUBSCRIPTION_DEPENDANT_LAYER_VERSION_1, 438 1, // number of dependencies for layer 439 SUBSCRIPTION_LAYER_ID, 440 MOCK_PUBLISHER_LAYER_SUBTYPE, 441 SUBSCRIPTION_LAYER_VERSION, 442 }; 443 444 445 // Inject second offer. 446 getMockHalClient().sendMessage(offeringMessage2); 447 448 // Verify applications API. 449 availableLayers = getMockSubscriberClient().receiveLayerAvailability(); 450 assertEquals( 451 new HashSet<>(Arrays.asList( 452 SUBSCRIPTION_ASSOCIATED_LAYER, 453 SUBSCRIPTION_DEPENDANT_ASSOCIATED_LAYER_1 454 )), 455 availableLayers.getAssociatedLayers()); 456 assertEquals(2, availableLayers.getSequence()); 457 458 // Verify HAL API. 459 values = getMockHalClient().receiveMessage().value.int32Values; 460 messageType = values[VmsAvailabilityStateIntegerValuesIndex.MESSAGE_TYPE]; 461 sequenceNumber = values[VmsAvailabilityStateIntegerValuesIndex.SEQUENCE_NUMBER]; 462 numberLayers = 463 values[VmsAvailabilityStateIntegerValuesIndex.NUMBER_OF_ASSOCIATED_LAYERS]; 464 465 assertEquals(messageType, VmsMessageType.AVAILABILITY_CHANGE); 466 assertEquals(2, sequenceNumber); 467 assertEquals(2, numberLayers); 468 469 } 470 471 // Test GetAvailableLayers(). 472 @Test testGetAvailableLayers()473 public void testGetAvailableLayers() throws Exception { 474 // 475 // Offering: 476 // Layer | Dependency 477 // =============================== 478 // (2, 3, 444), [17] | {} 479 480 // Expected availability: 481 // {(2, 3, 444 [17])} 482 // 483 getMockHalClient().sendMessage( 484 VmsMessageType.OFFERING, // MessageType 485 PUBLISHER_ID, 486 1, // Number of offered layers 487 488 SUBSCRIPTION_LAYER_ID, 489 MOCK_PUBLISHER_LAYER_SUBTYPE, 490 SUBSCRIPTION_LAYER_VERSION, 491 0 // number of dependencies for layer 492 ); 493 494 // Wait for an availability update to the subscriber to guarantee the state is settled. 495 getMockSubscriberClient().receiveLayerAvailability(); 496 497 VmsAvailableLayers availableLayers = getSubscriberManager().getAvailableLayers(); 498 assertEquals( 499 Collections.singleton(SUBSCRIPTION_ASSOCIATED_LAYER), 500 availableLayers.getAssociatedLayers()); 501 assertEquals(1, availableLayers.getSequence()); 502 } 503 } 504