612 lines
25 KiB
C++
612 lines
25 KiB
C++
/*
|
|
* Copyright (C) 2018 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.
|
|
*/
|
|
|
|
#include <android/hardware/automotive/vehicle/2.0/IVehicle.h>
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "VehicleHalTestUtils.h"
|
|
#include "vhal_v2_0/VmsUtils.h"
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace automotive {
|
|
namespace vehicle {
|
|
namespace V2_0 {
|
|
namespace vms {
|
|
|
|
namespace {
|
|
|
|
TEST(VmsUtilsTest, subscribeMessage) {
|
|
VmsLayer layer(1, 0, 2);
|
|
auto message = createSubscribeMessage(layer);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x4ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::SUBSCRIBE);
|
|
|
|
// Layer
|
|
EXPECT_EQ(message->value.int32Values[1], 1);
|
|
EXPECT_EQ(message->value.int32Values[2], 0);
|
|
EXPECT_EQ(message->value.int32Values[3], 2);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, unsubscribeMessage) {
|
|
VmsLayer layer(1, 0, 2);
|
|
auto message = createUnsubscribeMessage(layer);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x4ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::UNSUBSCRIBE);
|
|
|
|
// Layer
|
|
EXPECT_EQ(message->value.int32Values[1], 1);
|
|
EXPECT_EQ(message->value.int32Values[2], 0);
|
|
EXPECT_EQ(message->value.int32Values[3], 2);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, singleOfferingMessage) {
|
|
VmsOffers offers = {123, {VmsLayerOffering(VmsLayer(1, 0, 2))}};
|
|
auto message = createOfferingMessage(offers);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x7ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::OFFERING);
|
|
|
|
// Publisher ID
|
|
EXPECT_EQ(message->value.int32Values[1], 123);
|
|
|
|
// Number of layer offerings
|
|
EXPECT_EQ(message->value.int32Values[2], 1);
|
|
|
|
// Layer
|
|
EXPECT_EQ(message->value.int32Values[3], 1);
|
|
EXPECT_EQ(message->value.int32Values[4], 0);
|
|
EXPECT_EQ(message->value.int32Values[5], 2);
|
|
|
|
// Number of dependencies
|
|
EXPECT_EQ(message->value.int32Values[6], 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, offeringWithDependencies) {
|
|
VmsLayer layer(1, 0, 2);
|
|
std::vector<VmsLayer> dependencies = {VmsLayer(2, 0, 2), VmsLayer(3, 0, 3)};
|
|
std::vector<VmsLayerOffering> offering = {VmsLayerOffering(layer, dependencies)};
|
|
VmsOffers offers = {123, offering};
|
|
auto message = createOfferingMessage(offers);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0xdul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::OFFERING);
|
|
|
|
// Publisher ID
|
|
EXPECT_EQ(message->value.int32Values[1], 123);
|
|
|
|
// Number of layer offerings
|
|
EXPECT_EQ(message->value.int32Values[2], 1);
|
|
|
|
// Layer
|
|
EXPECT_EQ(message->value.int32Values[3], 1);
|
|
EXPECT_EQ(message->value.int32Values[4], 0);
|
|
EXPECT_EQ(message->value.int32Values[5], 2);
|
|
|
|
// Number of dependencies
|
|
EXPECT_EQ(message->value.int32Values[6], 2);
|
|
|
|
// Dependency 1
|
|
EXPECT_EQ(message->value.int32Values[7], 2);
|
|
EXPECT_EQ(message->value.int32Values[8], 0);
|
|
EXPECT_EQ(message->value.int32Values[9], 2);
|
|
|
|
// Dependency 2
|
|
EXPECT_EQ(message->value.int32Values[10], 3);
|
|
EXPECT_EQ(message->value.int32Values[11], 0);
|
|
EXPECT_EQ(message->value.int32Values[12], 3);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, availabilityMessage) {
|
|
auto message = createAvailabilityRequest();
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x1ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::AVAILABILITY_REQUEST);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscriptionsMessage) {
|
|
auto message = createSubscriptionsRequest();
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x1ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::SUBSCRIPTIONS_REQUEST);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, dataMessage) {
|
|
const std::string bytes = "aaa";
|
|
const VmsLayerAndPublisher layer_and_publisher(VmsLayer(2, 0, 1), 123);
|
|
auto message = createDataMessageWithLayerPublisherInfo(layer_and_publisher, bytes);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x5ul);
|
|
EXPECT_EQ(message->value.int32Values[0], toInt(VmsMessageType::DATA));
|
|
|
|
// Layer
|
|
EXPECT_EQ(message->value.int32Values[1], 2);
|
|
EXPECT_EQ(message->value.int32Values[2], 0);
|
|
EXPECT_EQ(message->value.int32Values[3], 1);
|
|
|
|
// Publisher ID
|
|
EXPECT_EQ(message->value.int32Values[4], 123);
|
|
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::DATA);
|
|
EXPECT_EQ(message->value.bytes.size(), bytes.size());
|
|
EXPECT_EQ(memcmp(message->value.bytes.data(), bytes.data(), bytes.size()), 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, emptyMessageInvalid) {
|
|
VehiclePropValue empty_prop;
|
|
EXPECT_FALSE(isValidVmsMessage(empty_prop));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, invalidMessageType) {
|
|
VmsLayer layer(1, 0, 2);
|
|
auto message = createSubscribeMessage(layer);
|
|
message->value.int32Values[0] = -1;
|
|
|
|
EXPECT_FALSE(isValidVmsMessage(*message));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, parseDataMessage) {
|
|
const std::string bytes = "aaa";
|
|
const VmsLayerAndPublisher layer_and_publisher(VmsLayer(1, 0, 1), 123);
|
|
auto message = createDataMessageWithLayerPublisherInfo(layer_and_publisher, bytes);
|
|
auto data_str = parseData(*message);
|
|
ASSERT_FALSE(data_str.empty());
|
|
EXPECT_EQ(data_str, bytes);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, parseInvalidDataMessage) {
|
|
VmsLayer layer(1, 0, 2);
|
|
auto message = createSubscribeMessage(layer);
|
|
auto data_str = parseData(*message);
|
|
EXPECT_TRUE(data_str.empty());
|
|
}
|
|
|
|
TEST(VmsUtilsTest, publisherIdRequest) {
|
|
std::string bytes = "pub_id";
|
|
auto message = createPublisherIdRequest(bytes);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x1ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::PUBLISHER_ID_REQUEST);
|
|
EXPECT_EQ(message->value.bytes.size(), bytes.size());
|
|
EXPECT_EQ(memcmp(message->value.bytes.data(), bytes.data(), bytes.size()), 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, validPublisherIdResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::PUBLISHER_ID_RESPONSE), 1234};
|
|
EXPECT_EQ(parsePublisherIdResponse(*message), 1234);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, invalidPublisherIdResponse) {
|
|
auto message = createBaseVmsMessage(1);
|
|
EXPECT_EQ(parsePublisherIdResponse(*message), -1);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, validSequenceNumberForSubscriptionsChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_CHANGE), 1234};
|
|
EXPECT_EQ(getSequenceNumberForSubscriptionsState(*message), 1234);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, validSequenceNumberForSubscriptionsResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_RESPONSE), 1234};
|
|
EXPECT_EQ(getSequenceNumberForSubscriptionsState(*message), 1234);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, invalidSubscriptionsState) {
|
|
auto message = createBaseVmsMessage(1);
|
|
EXPECT_EQ(getSequenceNumberForSubscriptionsState(*message), -1);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForExistingSmallerNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_CHANGE), 1234};
|
|
EXPECT_TRUE(isSequenceNumberNewer(*message, 1233));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForExistingSmallerNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_RESPONSE), 1234};
|
|
EXPECT_TRUE(isSequenceNumberNewer(*message, 1233));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForExistingGreaterNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_CHANGE), 1234};
|
|
EXPECT_FALSE(isSequenceNumberNewer(*message, 1235));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForExistingGreaterNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_RESPONSE), 1234};
|
|
EXPECT_FALSE(isSequenceNumberNewer(*message, 1235));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForSameNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_CHANGE), 1234};
|
|
EXPECT_FALSE(isSequenceNumberNewer(*message, 1234));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newSequenceNumberForSameNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::SUBSCRIPTIONS_RESPONSE), 1234};
|
|
EXPECT_FALSE(isSequenceNumberNewer(*message, 1234));
|
|
}
|
|
|
|
void testSubscribedLayers(VmsMessageType type) {
|
|
VmsOffers offers = {123,
|
|
{VmsLayerOffering(VmsLayer(1, 0, 1), {VmsLayer(4, 1, 1)}),
|
|
VmsLayerOffering(VmsLayer(2, 0, 1))}};
|
|
auto message = createBaseVmsMessage(16);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type),
|
|
1234, // sequence number
|
|
2, // number of layers
|
|
1, // number of associated layers
|
|
1, // layer 1
|
|
0, 1,
|
|
4, // layer 2
|
|
1, 1,
|
|
2, // associated layer
|
|
0, 1,
|
|
2, // number of publisher IDs
|
|
111, // publisher IDs
|
|
123};
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
auto result = getSubscribedLayers(*message, offers);
|
|
EXPECT_EQ(static_cast<int>(result.size()), 2);
|
|
EXPECT_EQ(result.at(0), VmsLayer(1, 0, 1));
|
|
EXPECT_EQ(result.at(1), VmsLayer(2, 0, 1));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersForChange) {
|
|
testSubscribedLayers(VmsMessageType::SUBSCRIPTIONS_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersForResponse) {
|
|
testSubscribedLayers(VmsMessageType::SUBSCRIPTIONS_RESPONSE);
|
|
}
|
|
|
|
void testGetSubscribedLayersMalformedData(VmsMessageType type) {
|
|
VmsOffers offers = {123,
|
|
{VmsLayerOffering(VmsLayer(1, 0, 1), {VmsLayer(4, 1, 1)}),
|
|
VmsLayerOffering(VmsLayer(2, 0, 1))}};
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type), 1234}; // sequence number
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
auto result = getSubscribedLayers(*message, offers);
|
|
EXPECT_EQ(static_cast<int>(result.size()), 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersForMalformedChange) {
|
|
testGetSubscribedLayersMalformedData(VmsMessageType::SUBSCRIPTIONS_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersForMalformedResponse) {
|
|
testGetSubscribedLayersMalformedData(VmsMessageType::SUBSCRIPTIONS_RESPONSE);
|
|
}
|
|
|
|
void testSubscribedLayersWithDifferentSubtype(VmsMessageType type) {
|
|
VmsOffers offers = {123, {VmsLayerOffering(VmsLayer(1, 0, 1))}};
|
|
auto message = createBaseVmsMessage(7);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type),
|
|
1234, // sequence number
|
|
1, // number of layers
|
|
0, // number of associated layers
|
|
1, // layer 1
|
|
1, // different subtype
|
|
1};
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_TRUE(getSubscribedLayers(*message, offers).empty());
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentSubtypeForChange) {
|
|
testSubscribedLayersWithDifferentSubtype(VmsMessageType::SUBSCRIPTIONS_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentSubtypeForResponse) {
|
|
testSubscribedLayersWithDifferentSubtype(VmsMessageType::SUBSCRIPTIONS_RESPONSE);
|
|
}
|
|
|
|
void subscribedLayersWithDifferentVersion(VmsMessageType type) {
|
|
VmsOffers offers = {123, {VmsLayerOffering(VmsLayer(1, 0, 1))}};
|
|
auto message = createBaseVmsMessage(7);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type),
|
|
1234, // sequence number
|
|
1, // number of layers
|
|
0, // number of associated layers
|
|
1, // layer 1
|
|
0, 2}; // different version
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_TRUE(getSubscribedLayers(*message, offers).empty());
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentVersionForChange) {
|
|
subscribedLayersWithDifferentVersion(VmsMessageType::SUBSCRIPTIONS_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentVersionForResponse) {
|
|
subscribedLayersWithDifferentVersion(VmsMessageType::SUBSCRIPTIONS_RESPONSE);
|
|
}
|
|
|
|
void subscribedLayersWithDifferentPublisherId(VmsMessageType type) {
|
|
VmsOffers offers = {123, {VmsLayerOffering(VmsLayer(1, 0, 1))}};
|
|
auto message = createBaseVmsMessage(9);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type),
|
|
1234, // sequence number
|
|
0, // number of layers
|
|
1, // number of associated layers
|
|
1, // associated layer 1
|
|
0, 1,
|
|
1, // number of publisher IDs
|
|
234}; // publisher ID 1
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_TRUE(getSubscribedLayers(*message, offers).empty());
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentPublisherIdForChange) {
|
|
subscribedLayersWithDifferentPublisherId(VmsMessageType::SUBSCRIPTIONS_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, subscribedLayersWithDifferentPublisherIdForResponse) {
|
|
subscribedLayersWithDifferentPublisherId(VmsMessageType::SUBSCRIPTIONS_RESPONSE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, serviceNewlyStarted) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 0};
|
|
EXPECT_TRUE(hasServiceNewlyStarted(*message));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, serviceNotNewlyStarted) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 1234};
|
|
EXPECT_FALSE(hasServiceNewlyStarted(*message));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, invalidAvailabilityChange) {
|
|
auto message = createBaseVmsMessage(1);
|
|
EXPECT_FALSE(hasServiceNewlyStarted(*message));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionRequest) {
|
|
auto message = createStartSessionMessage(123, 456);
|
|
ASSERT_NE(message, nullptr);
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
EXPECT_EQ(message->prop, toInt(VehicleProperty::VEHICLE_MAP_SERVICE));
|
|
EXPECT_EQ(message->value.int32Values.size(), 0x3ul);
|
|
EXPECT_EQ(parseMessageType(*message), VmsMessageType::START_SESSION);
|
|
EXPECT_EQ(message->value.int32Values[1], 123);
|
|
EXPECT_EQ(message->value.int32Values[2], 456);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionServiceNewlyStarted) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 123, -1};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, 122, 456, &new_service_id),
|
|
VmsSessionStatus::kNewServerSession);
|
|
EXPECT_EQ(new_service_id, 123);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionServiceNewlyStartedEdgeCase) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 0, -1};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, -1, 0, &new_service_id),
|
|
VmsSessionStatus::kNewServerSession);
|
|
EXPECT_EQ(new_service_id, 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionClientNewlyStarted) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 123, 456};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, -1, 456, &new_service_id),
|
|
VmsSessionStatus::kAckToCurrentSession);
|
|
EXPECT_EQ(new_service_id, 123);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionClientNewlyStartedWithSameServerAndClientId) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 123, 456};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, 123, 456, &new_service_id),
|
|
VmsSessionStatus::kAckToCurrentSession);
|
|
EXPECT_EQ(new_service_id, 123);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionWithZeroAsIds) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 0, 0};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, 0, 0, &new_service_id),
|
|
VmsSessionStatus::kAckToCurrentSession);
|
|
EXPECT_EQ(new_service_id, 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionOldServiceId) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 120, 456};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, 123, 456, &new_service_id),
|
|
VmsSessionStatus::kAckToCurrentSession);
|
|
EXPECT_EQ(new_service_id, 120);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionNegativeServerId) {
|
|
auto message = createBaseVmsMessage(3);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), -1, 456};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, -1, 456, &new_service_id),
|
|
VmsSessionStatus::kAckToCurrentSession);
|
|
EXPECT_EQ(new_service_id, -1);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, startSessionInvalidMessageFormat) {
|
|
auto message = createBaseVmsMessage(2);
|
|
int new_service_id;
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(VmsMessageType::START_SESSION), 123};
|
|
EXPECT_EQ(parseStartSessionMessage(*message, 123, 456, &new_service_id),
|
|
VmsSessionStatus::kInvalidMessage);
|
|
EXPECT_EQ(new_service_id, 123);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForExistingSmallerNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 1234};
|
|
EXPECT_TRUE(isAvailabilitySequenceNumberNewer(*message, 1233));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForExistingSmallerNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_RESPONSE), 1234};
|
|
EXPECT_TRUE(isAvailabilitySequenceNumberNewer(*message, 1233));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForExistingGreaterNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 1234};
|
|
EXPECT_FALSE(isAvailabilitySequenceNumberNewer(*message, 1235));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForExistingGreaterNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_RESPONSE), 1234};
|
|
EXPECT_FALSE(isAvailabilitySequenceNumberNewer(*message, 1235));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForSameNumberForChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 1234};
|
|
EXPECT_FALSE(isAvailabilitySequenceNumberNewer(*message, 1234));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, newAvailabilitySequenceNumberForSameNumberForResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_RESPONSE), 1234};
|
|
EXPECT_FALSE(isAvailabilitySequenceNumberNewer(*message, 1234));
|
|
}
|
|
|
|
TEST(VmsUtilsTest, validSequenceNumberForAvailabilityChange) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_CHANGE), 1234};
|
|
EXPECT_EQ(getSequenceNumberForAvailabilityState(*message), 1234);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, validSequenceNumberForAvailabilityResponse) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values =
|
|
hidl_vec<int32_t>{toInt(VmsMessageType::AVAILABILITY_RESPONSE), 1234};
|
|
EXPECT_EQ(getSequenceNumberForAvailabilityState(*message), 1234);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, invalidAvailabilityState) {
|
|
auto message = createBaseVmsMessage(1);
|
|
EXPECT_EQ(getSequenceNumberForAvailabilityState(*message), -1);
|
|
}
|
|
|
|
void testGetAvailableLayers(VmsMessageType type) {
|
|
auto message = createBaseVmsMessage(13);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type),
|
|
1234, // sequence number
|
|
2, // number of associated layers
|
|
1, // associated layer 1
|
|
0, 1,
|
|
2, // number of publisher IDs
|
|
111, // publisher IDs
|
|
123,
|
|
2, // associated layer 2
|
|
0, 1, 0}; // number of publisher IDs
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
auto result = getAvailableLayers(*message);
|
|
EXPECT_EQ(static_cast<int>(result.size()), 2);
|
|
EXPECT_EQ(result.at(0).layer, VmsLayer(1, 0, 1));
|
|
EXPECT_EQ(result.at(0).publisher_ids.at(0), 111);
|
|
EXPECT_EQ(result.at(0).publisher_ids.at(1), 123);
|
|
EXPECT_EQ(result.at(1).layer, VmsLayer(2, 0, 1));
|
|
EXPECT_EQ(static_cast<int>(result.at(1).publisher_ids.size()), 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, availableLayersForChange) {
|
|
testGetAvailableLayers(VmsMessageType::AVAILABILITY_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, availableLayersForResponse) {
|
|
testGetAvailableLayers(VmsMessageType::AVAILABILITY_RESPONSE);
|
|
}
|
|
|
|
void testGetAvailableLayersMalformedData(VmsMessageType type) {
|
|
auto message = createBaseVmsMessage(2);
|
|
message->value.int32Values = hidl_vec<int32_t>{toInt(type), 1234}; // sequence number
|
|
EXPECT_TRUE(isValidVmsMessage(*message));
|
|
auto result = getAvailableLayers(*message);
|
|
EXPECT_EQ(static_cast<int>(result.size()), 0);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, availableLayersForMalformedChange) {
|
|
testGetAvailableLayersMalformedData(VmsMessageType::AVAILABILITY_CHANGE);
|
|
}
|
|
|
|
TEST(VmsUtilsTest, availableLayersForMalformedResponse) {
|
|
testGetAvailableLayersMalformedData(VmsMessageType::AVAILABILITY_RESPONSE);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
} // namespace vms
|
|
} // namespace V2_0
|
|
} // namespace vehicle
|
|
} // namespace automotive
|
|
} // namespace hardware
|
|
} // namespace android
|