Merge "Add all prior VTS tests" (2e0516bf) · Commits · e / os / android_hardware_interfaces

radio/aidl/vts/radio_config_response.cpp

+16 −7

Original line number	Diff line number	Diff line
		@@ -19,12 +19,15 @@
		RadioConfigResponse::RadioConfigResponse(RadioServiceTest& parent) : parent_config(parent) {}

		ndk::ScopedAStatus RadioConfigResponse::getSimSlotsStatusResponse(
		const RadioResponseInfo& /* info /, const std::vector<SimSlotStatus>& / slotStatus */) {
		const RadioResponseInfo& info, const std::vector<SimSlotStatus>& /* slotStatus */) {
		rspInfo = info;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioConfigResponse::setSimSlotsMappingResponse(
		const RadioResponseInfo& /* info */) {
		ndk::ScopedAStatus RadioConfigResponse::setSimSlotsMappingResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		@@ -37,22 +40,28 @@ ndk::ScopedAStatus RadioConfigResponse::getPhoneCapabilityResponse(
		}

		ndk::ScopedAStatus RadioConfigResponse::setPreferredDataModemResponse(
		const RadioResponseInfo& /* info */) {
		const RadioResponseInfo& info) {
		rspInfo = info;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioConfigResponse::getNumOfLiveModemsResponse(
		const RadioResponseInfo& /* info /, const int8_t / numOfLiveModems */) {
		const RadioResponseInfo& info, const int8_t /* numOfLiveModems */) {
		rspInfo = info;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioConfigResponse::setNumOfLiveModemsResponse(
		const RadioResponseInfo& /* info */) {
		ndk::ScopedAStatus RadioConfigResponse::setNumOfLiveModemsResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioConfigResponse::getHalDeviceCapabilitiesResponse(
		const RadioResponseInfo& info, bool modemReducedFeatures) {
		rspInfo = info;
		modemReducedFeatureSet1 = modemReducedFeatures;
		parent_config.notify(info.serial);
		return ndk::ScopedAStatus::ok();

radio/aidl/vts/radio_config_test.cpp

+99 −0

Original line number	Diff line number	Diff line
		@@ -54,3 +54,102 @@ TEST_P(RadioConfigTest, getHalDeviceCapabilities) {
		ALOGI("getHalDeviceCapabilities, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());
		}

		/*
		* Test IRadioConfig.getSimSlotsStatus() for the response returned.
		*/
		TEST_P(RadioConfigTest, getSimSlotsStatus) {
		serial = GetRandomSerialNumber();
		ndk::ScopedAStatus res = radio_config->getSimSlotsStatus(serial);
		ASSERT_OK(res);
		ALOGI("getSimSlotsStatus, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());
		}

		/*
		* Test IRadioConfig.getPhoneCapability() for the response returned.
		*/
		TEST_P(RadioConfigTest, getPhoneCapability) {
		serial = GetRandomSerialNumber();
		ndk::ScopedAStatus res = radio_config->getPhoneCapability(serial);
		ASSERT_OK(res);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_config->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_config->rspInfo.serial);
		ALOGI("getPhoneCapability, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());

		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_config->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));

		if (radioRsp_config->rspInfo.error == RadioError ::NONE) {
		// maxActiveData should be greater than or equal to maxActiveInternetData.
		EXPECT_GE(radioRsp_config->phoneCap.maxActiveData,
		radioRsp_config->phoneCap.maxActiveInternetData);
		// maxActiveData and maxActiveInternetData should be 0 or positive numbers.
		EXPECT_GE(radioRsp_config->phoneCap.maxActiveInternetData, 0);
		}
		}

		/*
		* Test IRadioConfig.setPreferredDataModem() for the response returned.
		*/
		TEST_P(RadioConfigTest, setPreferredDataModem) {
		serial = GetRandomSerialNumber();
		ndk::ScopedAStatus res = radio_config->getPhoneCapability(serial);
		ASSERT_OK(res);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_config->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_config->rspInfo.serial);
		ALOGI("getPhoneCapability, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());

		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_config->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));

		if (radioRsp_config->rspInfo.error != RadioError ::NONE) {
		return;
		}

		if (radioRsp_config->phoneCap.logicalModemIds.size() == 0) {
		return;
		}

		// We get phoneCapability. Send setPreferredDataModem command
		serial = GetRandomSerialNumber();
		uint8_t modemId = radioRsp_config->phoneCap.logicalModemIds[0];
		res = radio_config->setPreferredDataModem(serial, modemId);

		ASSERT_OK(res);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_config->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_config->rspInfo.serial);
		ALOGI("setPreferredDataModem, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());

		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_config->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INTERNAL_ERR}));
		}

		/*
		* Test IRadioConfig.setPreferredDataModem() with invalid arguments.
		*/
		TEST_P(RadioConfigTest, setPreferredDataModem_invalidArgument) {
		serial = GetRandomSerialNumber();
		uint8_t modemId = -1;
		ndk::ScopedAStatus res = radio_config->setPreferredDataModem(serial, modemId);

		ASSERT_OK(res);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_config->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_config->rspInfo.serial);
		ALOGI("setPreferredDataModem, rspInfo.error = %s\n",
		toString(radioRsp_config->rspInfo.error).c_str());

		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_config->rspInfo.error,
		{RadioError::INVALID_ARGUMENTS, RadioError::RADIO_NOT_AVAILABLE,
		RadioError::INTERNAL_ERR}));
		}

radio/aidl/vts/radio_data_response.cpp

+18 −8

Original line number	Diff line number	Diff line
		@@ -36,8 +36,9 @@ ndk::ScopedAStatus RadioDataResponse::cancelHandoverResponse(const RadioResponse
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::deactivateDataCallResponse(
		const RadioResponseInfo& /info/) {
		ndk::ScopedAStatus RadioDataResponse::deactivateDataCallResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		@@ -61,11 +62,15 @@ ndk::ScopedAStatus RadioDataResponse::releasePduSessionIdResponse(const RadioRes
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::setDataAllowedResponse(const RadioResponseInfo& /info/) {
		ndk::ScopedAStatus RadioDataResponse::setDataAllowedResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::setDataProfileResponse(const RadioResponseInfo& /info/) {
		ndk::ScopedAStatus RadioDataResponse::setDataProfileResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		@@ -75,8 +80,9 @@ ndk::ScopedAStatus RadioDataResponse::setDataThrottlingResponse(const RadioRespo
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::setInitialAttachApnResponse(
		const RadioResponseInfo& /info/) {
		ndk::ScopedAStatus RadioDataResponse::setInitialAttachApnResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		@@ -94,11 +100,15 @@ ndk::ScopedAStatus RadioDataResponse::startHandoverResponse(const RadioResponseI
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::startKeepaliveResponse(const RadioResponseInfo& /info/,
		ndk::ScopedAStatus RadioDataResponse::startKeepaliveResponse(const RadioResponseInfo& info,
		const KeepaliveStatus& /status/) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

		ndk::ScopedAStatus RadioDataResponse::stopKeepaliveResponse(const RadioResponseInfo& /info/) {
		ndk::ScopedAStatus RadioDataResponse::stopKeepaliveResponse(const RadioResponseInfo& info) {
		rspInfo = info;
		parent_data.notify(info.serial);
		return ndk::ScopedAStatus::ok();
		}

radio/aidl/vts/radio_data_test.cpp

+277 −0

Original line number	Diff line number	Diff line
		@@ -309,3 +309,280 @@ TEST_P(RadioDataTest, setDataThrottling) {

		sleep(1);
		}

		/*
		* Test IRadioData.setInitialAttachApn() for the response returned.
		*/
		TEST_P(RadioDataTest, setInitialAttachApn) {
		serial = GetRandomSerialNumber();

		// Create a dataProfileInfo
		DataProfileInfo dataProfileInfo;
		memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
		dataProfileInfo.profileId = DataProfileInfo::ID_DEFAULT;
		dataProfileInfo.apn = std::string("internet");
		dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
		dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
		dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
		dataProfileInfo.user = std::string("username");
		dataProfileInfo.password = std::string("password");
		dataProfileInfo.type = DataProfileInfo::TYPE_THREE_GPP;
		dataProfileInfo.maxConnsTime = 300;
		dataProfileInfo.maxConns = 20;
		dataProfileInfo.waitTime = 0;
		dataProfileInfo.enabled = true;
		dataProfileInfo.supportedApnTypesBitmap = 320;
		dataProfileInfo.bearerBitmap = 161543;
		dataProfileInfo.mtuV4 = 0;
		dataProfileInfo.mtuV6 = 0;
		dataProfileInfo.preferred = true;
		dataProfileInfo.persistent = false;

		radio_data->setInitialAttachApn(serial, dataProfileInfo);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
		} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
		}
		}

		/*
		* Test IRadioData.setDataProfile() for the response returned.
		*/
		TEST_P(RadioDataTest, setDataProfile) {
		serial = GetRandomSerialNumber();

		// Create a dataProfileInfo
		DataProfileInfo dataProfileInfo;
		memset(&dataProfileInfo, 0, sizeof(dataProfileInfo));
		dataProfileInfo.profileId = DataProfileInfo::ID_DEFAULT;
		dataProfileInfo.apn = std::string("internet");
		dataProfileInfo.protocol = PdpProtocolType::IPV4V6;
		dataProfileInfo.roamingProtocol = PdpProtocolType::IPV4V6;
		dataProfileInfo.authType = ApnAuthType::NO_PAP_NO_CHAP;
		dataProfileInfo.user = std::string("username");
		dataProfileInfo.password = std::string("password");
		dataProfileInfo.type = DataProfileInfo::TYPE_THREE_GPP;
		dataProfileInfo.maxConnsTime = 300;
		dataProfileInfo.maxConns = 20;
		dataProfileInfo.waitTime = 0;
		dataProfileInfo.enabled = true;
		dataProfileInfo.supportedApnTypesBitmap = 320;
		dataProfileInfo.bearerBitmap = 161543;
		dataProfileInfo.mtuV4 = 0;
		dataProfileInfo.mtuV6 = 0;
		dataProfileInfo.preferred = true;
		dataProfileInfo.persistent = true;

		// Create a dataProfileInfoList
		std::vector<DataProfileInfo> dataProfileInfoList = {dataProfileInfo};

		radio_data->setDataProfile(serial, dataProfileInfoList);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::SIM_ABSENT, RadioError::RADIO_NOT_AVAILABLE}));
		} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
		ASSERT_TRUE(CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE}));
		}
		}

		/*
		* Test IRadioData.deactivateDataCall() for the response returned.
		*/
		TEST_P(RadioDataTest, deactivateDataCall) {
		serial = GetRandomSerialNumber();
		int cid = 1;
		DataRequestReason reason = DataRequestReason::NORMAL;

		ndk::ScopedAStatus res = radio_data->deactivateDataCall(serial, cid, reason);
		ASSERT_OK(res);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(
		CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
		RadioError::INVALID_CALL_ID, RadioError::INVALID_STATE,
		RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED,
		RadioError::CANCELLED, RadioError::SIM_ABSENT}));
		} else if (cardStatus.cardState == CardStatus::STATE_PRESENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_CALL_ID,
		RadioError::INVALID_STATE, RadioError::INVALID_ARGUMENTS,
		RadioError::REQUEST_NOT_SUPPORTED, RadioError::CANCELLED}));
		}
		}

		/*
		* Test IRadioData.startKeepalive() for the response returned.
		*/
		TEST_P(RadioDataTest, startKeepalive) {
		std::vector<KeepaliveRequest> requests = {
		{
		// Invalid IPv4 source address
		KeepaliveRequest::TYPE_NATT_IPV4,
		{192, 168, 0 /, 100/},
		1234,
		{8, 8, 4, 4},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid IPv4 destination address
		KeepaliveRequest::TYPE_NATT_IPV4,
		{192, 168, 0, 100},
		1234,
		{8, 8, 4, 4, 1, 2, 3, 4},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid Keepalive Type
		-1,
		{192, 168, 0, 100},
		1234,
		{8, 8, 4, 4},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid IPv6 source address
		KeepaliveRequest::TYPE_NATT_IPV6,
		{0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE,
		0xED, 0xBE, 0xEF, 0xBD},
		1234,
		{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x88, 0x44},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid IPv6 destination address
		KeepaliveRequest::TYPE_NATT_IPV6,
		{0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE,
		0xED, 0xBE, 0xEF},
		1234,
		{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x88,
		/0x44/},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid Context ID (cid), this should survive the initial
		// range checking and fail in the modem data layer
		KeepaliveRequest::TYPE_NATT_IPV4,
		{192, 168, 0, 100},
		1234,
		{8, 8, 4, 4},
		4500,
		20000,
		0xBAD,
		},
		{
		// Invalid Context ID (cid), this should survive the initial
		// range checking and fail in the modem data layer
		KeepaliveRequest::TYPE_NATT_IPV6,
		{0xDE, 0xAD, 0xBE, 0xEF, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFE,
		0xED, 0xBE, 0xEF},
		1234,
		{0x20, 0x01, 0x48, 0x60, 0x48, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
		0x00, 0x88, 0x44},
		4500,
		20000,
		0xBAD,
		}};

		for (auto req = requests.begin(); req != requests.end(); req++) {
		serial = GetRandomSerialNumber();
		radio_data->startKeepalive(serial, *req);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::INVALID_ARGUMENTS,
		RadioError::REQUEST_NOT_SUPPORTED}));
		}
		}

		/*
		* Test IRadioData.stopKeepalive() for the response returned.
		*/
		TEST_P(RadioDataTest, stopKeepalive) {
		serial = GetRandomSerialNumber();

		radio_data->stopKeepalive(serial, 0xBAD);
		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		ASSERT_TRUE(
		CheckAnyOfErrors(radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE,
		RadioError::INVALID_ARGUMENTS, RadioError::REQUEST_NOT_SUPPORTED}));
		}

		/*
		* Test IRadioData.getDataCallList() for the response returned.
		*/
		TEST_P(RadioDataTest, getDataCallList) {
		LOG(DEBUG) << "getDataCallList";
		serial = GetRandomSerialNumber();

		radio_data->getDataCallList(serial);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		ASSERT_TRUE(CheckAnyOfErrors(
		radioRsp_data->rspInfo.error,
		{RadioError::NONE, RadioError::RADIO_NOT_AVAILABLE, RadioError::SIM_ABSENT}));
		}
		LOG(DEBUG) << "getDataCallList finished";
		}

		/*
		* Test IRadioData.setDataAllowed() for the response returned.
		*/
		TEST_P(RadioDataTest, setDataAllowed) {
		LOG(DEBUG) << "setDataAllowed";
		serial = GetRandomSerialNumber();
		bool allow = true;

		radio_data->setDataAllowed(serial, allow);

		EXPECT_EQ(std::cv_status::no_timeout, wait());
		EXPECT_EQ(RadioResponseType::SOLICITED, radioRsp_data->rspInfo.type);
		EXPECT_EQ(serial, radioRsp_data->rspInfo.serial);

		if (cardStatus.cardState == CardStatus::STATE_ABSENT) {
		EXPECT_EQ(RadioError::NONE, radioRsp_data->rspInfo.error);
		}
		LOG(DEBUG) << "setDataAllowed finished";
		}

radio/aidl/vts/radio_messaging_response.cpp

+57 −24

File changed.

Preview size limit exceeded, changes collapsed.