You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
646 lines
20 KiB
646 lines
20 KiB
/*
|
|
* Copyright 2016 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 "VtsCompilerUtils.h"
|
|
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <sys/stat.h>
|
|
#include <sys/types.h>
|
|
#include <unistd.h>
|
|
|
|
#include <cstdint>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <sstream>
|
|
|
|
#include <google/protobuf/text_format.h>
|
|
|
|
#include "utils/InterfaceSpecUtil.h"
|
|
#include "utils/StringUtil.h"
|
|
|
|
#include "test/vts/proto/ComponentSpecificationMessage.pb.h"
|
|
|
|
using namespace std;
|
|
|
|
namespace android {
|
|
namespace vts {
|
|
|
|
string ComponentClassToString(int component_class) {
|
|
switch (component_class) {
|
|
case UNKNOWN_CLASS:
|
|
return "unknown_class";
|
|
case HAL_CONVENTIONAL:
|
|
return "hal_conventional";
|
|
case HAL_CONVENTIONAL_SUBMODULE:
|
|
return "hal_conventional_submodule";
|
|
case HAL_HIDL:
|
|
return "hal_hidl";
|
|
case HAL_HIDL_WRAPPED_CONVENTIONAL:
|
|
return "hal_hidl_wrapped_conventional";
|
|
case HAL_LEGACY:
|
|
return "hal_legacy";
|
|
case LIB_SHARED:
|
|
return "lib_shared";
|
|
}
|
|
cerr << "error: invalid component_class " << component_class << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
string ComponentTypeToString(int component_type) {
|
|
switch (component_type) {
|
|
case UNKNOWN_TYPE:
|
|
return "unknown_type";
|
|
case AUDIO:
|
|
return "audio";
|
|
case CAMERA:
|
|
return "camera";
|
|
case GPS:
|
|
return "gps";
|
|
case LIGHT:
|
|
return "light";
|
|
case WIFI:
|
|
return "wifi";
|
|
case MOBILE:
|
|
return "mobile";
|
|
case BLUETOOTH:
|
|
return "bluetooth";
|
|
case TV_INPUT:
|
|
return "tv_input";
|
|
case NFC:
|
|
return "nfc";
|
|
case VEHICLE:
|
|
return "vehicle";
|
|
case VIBRATOR:
|
|
return "vibrator";
|
|
case THERMAL:
|
|
return "thermal";
|
|
case CONTEXTHUB:
|
|
return "contexthub";
|
|
case SENSORS:
|
|
return "sensors";
|
|
case VR:
|
|
return "vr";
|
|
case GRAPHICS_ALLOCATOR:
|
|
return "graphics_allocator";
|
|
case GRAPHICS_MAPPER:
|
|
return "graphics_mapper";
|
|
case GRAPHICS_COMPOSER:
|
|
return "graphics_composer";
|
|
case BIONIC_LIBM:
|
|
return "bionic_libm";
|
|
case TV_CEC:
|
|
return "tv_cec";
|
|
case RADIO:
|
|
return "radio";
|
|
case MEDIA_OMX:
|
|
return "media_omx";
|
|
case BIONIC_LIBC:
|
|
return "bionic_libc";
|
|
case VNDK_LIBCUTILS:
|
|
return "vndk_libcutils";
|
|
}
|
|
cerr << "error: invalid component_type " << component_type << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
string GetCppVariableType(const std::string scalar_type_string) {
|
|
if (scalar_type_string == "void" ||
|
|
scalar_type_string == "int32_t" || scalar_type_string == "uint32_t" ||
|
|
scalar_type_string == "int8_t" || scalar_type_string == "uint8_t" ||
|
|
scalar_type_string == "int64_t" || scalar_type_string == "uint64_t" ||
|
|
scalar_type_string == "int16_t" || scalar_type_string == "uint16_t") {
|
|
return scalar_type_string;
|
|
} else if (scalar_type_string == "bool_t") {
|
|
return "bool";
|
|
} else if (scalar_type_string == "float_t") {
|
|
return "float";
|
|
} else if (scalar_type_string == "double_t") {
|
|
return "double";
|
|
} else if (scalar_type_string == "ufloat") {
|
|
return "unsigned float";
|
|
} else if (scalar_type_string == "udouble") {
|
|
return "unsigned double";
|
|
} else if (scalar_type_string == "string") {
|
|
return "std::string";
|
|
} else if (scalar_type_string == "pointer") {
|
|
return "void*";
|
|
} else if (scalar_type_string == "char_pointer") {
|
|
return "char*";
|
|
} else if (scalar_type_string == "uchar_pointer") {
|
|
return "unsigned char*";
|
|
} else if (scalar_type_string == "void_pointer") {
|
|
return "void*";
|
|
} else if (scalar_type_string == "function_pointer") {
|
|
return "void*";
|
|
}
|
|
|
|
cerr << __func__ << ":" << __LINE__ << " "
|
|
<< "error: unknown scalar_type " << scalar_type_string << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
string GetCppVariableType(const VariableSpecificationMessage& arg,
|
|
bool generate_const) {
|
|
string result;
|
|
switch (arg.type()) {
|
|
case TYPE_VOID:
|
|
{
|
|
return "void";
|
|
}
|
|
case TYPE_PREDEFINED:
|
|
{
|
|
result = arg.predefined_type();
|
|
break;
|
|
}
|
|
case TYPE_SCALAR:
|
|
{
|
|
result = GetCppVariableType(arg.scalar_type());
|
|
break;
|
|
}
|
|
case TYPE_STRING:
|
|
{
|
|
result = "::android::hardware::hidl_string";
|
|
break;
|
|
}
|
|
case TYPE_ENUM:
|
|
{
|
|
if (!arg.has_enum_value() && arg.has_predefined_type()) {
|
|
result = arg.predefined_type();
|
|
} else if (arg.has_enum_value() && arg.has_name()) {
|
|
result = arg.name(); // nested enum type.
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__
|
|
<< " ERROR no predefined_type set for enum variable" << endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_VECTOR:
|
|
{
|
|
string element_type = GetCppVariableType(arg.vector_value(0));
|
|
result = "::android::hardware::hidl_vec<" + element_type + ">";
|
|
break;
|
|
}
|
|
case TYPE_ARRAY:
|
|
{
|
|
VariableSpecificationMessage cur_val = arg;
|
|
vector<int32_t> array_sizes;
|
|
while (cur_val.type() == TYPE_ARRAY) {
|
|
array_sizes.push_back(cur_val.vector_size());
|
|
VariableSpecificationMessage temp = cur_val.vector_value(0);
|
|
cur_val = temp;
|
|
}
|
|
string element_type = GetCppVariableType(cur_val);
|
|
result = "::android::hardware::hidl_array<" + element_type + ", ";
|
|
for (size_t i = 0; i < array_sizes.size(); i++) {
|
|
result += to_string(array_sizes[i]);
|
|
if (i != array_sizes.size() - 1) result += ", ";
|
|
}
|
|
result += ">";
|
|
break;
|
|
}
|
|
case TYPE_STRUCT:
|
|
{
|
|
if (arg.struct_value_size() == 0 && arg.has_predefined_type()) {
|
|
result = arg.predefined_type();
|
|
} else if (arg.has_struct_type()) {
|
|
result = arg.struct_type();
|
|
} else if (arg.sub_struct_size() > 0 || arg.struct_value_size() > 0) {
|
|
result = arg.name();
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__ << " ERROR"
|
|
<< " no predefined_type, struct_type, nor sub_struct set"
|
|
<< " for struct variable"
|
|
<< " (arg name " << arg.name() << ")" << endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_UNION:
|
|
{
|
|
if (arg.union_value_size() == 0 && arg.has_predefined_type()) {
|
|
result = arg.predefined_type();
|
|
} else if (arg.has_union_type()) {
|
|
result = arg.union_type();
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__
|
|
<< " ERROR no predefined_type or union_type set for union"
|
|
<< " variable" << endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_SAFE_UNION: {
|
|
if (arg.safe_union_value_size() == 0 && arg.has_predefined_type()) {
|
|
result = arg.predefined_type();
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__
|
|
<< " ERROR no predefined_type set for safe union"
|
|
<< " variable" << endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_HIDL_CALLBACK:
|
|
{
|
|
if (arg.has_predefined_type()) {
|
|
result = "sp<" + arg.predefined_type() + ">";
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__
|
|
<< " ERROR no predefined_type set for hidl callback variable"
|
|
<< endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_HANDLE:
|
|
{
|
|
result = "::android::hardware::hidl_handle";
|
|
break;
|
|
}
|
|
case TYPE_HIDL_INTERFACE:
|
|
{
|
|
if (arg.has_predefined_type()) {
|
|
result = "sp<" + arg.predefined_type() + ">";
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__
|
|
<< " ERROR no predefined_type set for hidl interface variable"
|
|
<< endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_MASK:
|
|
{
|
|
result = GetCppVariableType(arg.scalar_type());
|
|
break;
|
|
}
|
|
case TYPE_HIDL_MEMORY:
|
|
{
|
|
result = "::android::hardware::hidl_memory";
|
|
break;
|
|
}
|
|
case TYPE_POINTER:
|
|
{
|
|
result = "void*";
|
|
if (generate_const) {
|
|
result = "const " + result;
|
|
}
|
|
return result;
|
|
}
|
|
case TYPE_FMQ_SYNC:
|
|
{
|
|
string element_type = GetCppVariableType(arg.fmq_value(0));
|
|
result = "::android::hardware::MQDescriptorSync<" + element_type + ">";
|
|
break;
|
|
}
|
|
case TYPE_FMQ_UNSYNC:
|
|
{
|
|
string element_type = GetCppVariableType(arg.fmq_value(0));
|
|
result = "::android::hardware::MQDescriptorUnsync<" + element_type + ">";
|
|
break;
|
|
}
|
|
case TYPE_REF:
|
|
{
|
|
VariableSpecificationMessage cur_val = arg;
|
|
int ref_depth = 0;
|
|
while (cur_val.type() == TYPE_REF) {
|
|
ref_depth++;
|
|
VariableSpecificationMessage temp = cur_val.ref_value();
|
|
cur_val = temp;
|
|
}
|
|
string element_type = GetCppVariableType(cur_val);
|
|
result = element_type;
|
|
for (int i = 0; i < ref_depth; i++) {
|
|
result += " const*";
|
|
}
|
|
return result;
|
|
break;
|
|
}
|
|
default:
|
|
{
|
|
cerr << __func__ << ":" << __LINE__ << " " << ": type " << arg.type()
|
|
<< " not supported" << endl;
|
|
exit(-1);
|
|
}
|
|
}
|
|
if (generate_const) {
|
|
return "const " + result + "&";
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string GetConversionToProtobufFunctionName(VariableSpecificationMessage arg) {
|
|
if (arg.type() == TYPE_PREDEFINED) {
|
|
if (arg.predefined_type() == "camera_info_t*") {
|
|
return "ConvertCameraInfoToProtobuf";
|
|
} else if (arg.predefined_type() == "hw_device_t**") {
|
|
return "";
|
|
} else {
|
|
cerr << __FILE__ << ":" << __LINE__ << " "
|
|
<< "error: unknown instance type " << arg.predefined_type() << endl;
|
|
}
|
|
}
|
|
cerr << __FUNCTION__ << ": non-supported type " << arg.type() << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
string GetCppInstanceType(
|
|
const VariableSpecificationMessage& arg,
|
|
const string& msg,
|
|
const ComponentSpecificationMessage* message) {
|
|
switch(arg.type()) {
|
|
case TYPE_PREDEFINED: {
|
|
if (arg.predefined_type() == "struct light_state_t*") {
|
|
if (msg.length() == 0) {
|
|
return "GenerateLightState()";
|
|
} else {
|
|
return "GenerateLightStateUsingMessage(" + msg + ")";
|
|
}
|
|
} else if (arg.predefined_type() == "GpsCallbacks*") {
|
|
return "GenerateGpsCallbacks()";
|
|
} else if (arg.predefined_type() == "GpsUtcTime") {
|
|
return "GenerateGpsUtcTime()";
|
|
} else if (arg.predefined_type() == "vts_gps_latitude") {
|
|
return "GenerateLatitude()";
|
|
} else if (arg.predefined_type() == "vts_gps_longitude") {
|
|
return "GenerateLongitude()";
|
|
} else if (arg.predefined_type() == "vts_gps_accuracy") {
|
|
return "GenerateGpsAccuracy()";
|
|
} else if (arg.predefined_type() == "vts_gps_flags_uint16") {
|
|
return "GenerateGpsFlagsUint16()";
|
|
} else if (arg.predefined_type() == "GpsPositionMode") {
|
|
return "GenerateGpsPositionMode()";
|
|
} else if (arg.predefined_type() == "GpsPositionRecurrence") {
|
|
return "GenerateGpsPositionRecurrence()";
|
|
} else if (arg.predefined_type() == "hw_module_t*") {
|
|
return "(hw_module_t*) malloc(sizeof(hw_module_t))";
|
|
} else if (arg.predefined_type() == "hw_module_t**") {
|
|
return "(hw_module_t**) malloc(sizeof(hw_module_t*))";
|
|
} else if (arg.predefined_type() == "hw_device_t**") {
|
|
return "(hw_device_t**) malloc(sizeof(hw_device_t*))";
|
|
} else if (arg.predefined_type() == "camera_info_t*") {
|
|
if (msg.length() == 0) {
|
|
return "GenerateCameraInfo()";
|
|
} else {
|
|
return "GenerateCameraInfoUsingMessage(" + msg + ")";
|
|
}
|
|
} else if (arg.predefined_type() == "camera_module_callbacks_t*") {
|
|
return "GenerateCameraModuleCallbacks()";
|
|
} else if (arg.predefined_type() == "camera_notify_callback") {
|
|
return "GenerateCameraNotifyCallback()";
|
|
} else if (arg.predefined_type() == "camera_data_callback") {
|
|
return "GenerateCameraDataCallback()";
|
|
} else if (arg.predefined_type() == "camera_data_timestamp_callback") {
|
|
return "GenerateCameraDataTimestampCallback()";
|
|
} else if (arg.predefined_type() == "camera_request_memory") {
|
|
return "GenerateCameraRequestMemory()";
|
|
} else if (arg.predefined_type() == "wifi_handle*") {
|
|
return "(wifi_handle*) malloc(sizeof(wifi_handle))";
|
|
} else if (arg.predefined_type() == "struct camera_device*") {
|
|
return "(struct camera_device*) malloc(sizeof(struct camera_device))";
|
|
} else if (arg.predefined_type() == "struct preview_stream_ops*") {
|
|
return "(preview_stream_ops*) malloc(sizeof(preview_stream_ops))";
|
|
} else if (endsWith(arg.predefined_type(), "*")) {
|
|
// known use cases: bt_callbacks_t
|
|
return "(" + arg.predefined_type() + ") malloc(sizeof("
|
|
+ arg.predefined_type().substr(0, arg.predefined_type().size() - 1)
|
|
+ "))";
|
|
} else {
|
|
cerr << __func__ << ":" << __LINE__ << " "
|
|
<< "error: unknown instance type " << arg.predefined_type() << endl;
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_SCALAR: {
|
|
if (arg.scalar_type() == "bool_t") {
|
|
return "RandomBool()";
|
|
} else if (arg.scalar_type() == "uint32_t") {
|
|
return "RandomUint32()";
|
|
} else if (arg.scalar_type() == "int32_t") {
|
|
return "RandomInt32()";
|
|
} else if (arg.scalar_type() == "uint64_t") {
|
|
return "RandomUint64()";
|
|
} else if (arg.scalar_type() == "int64_t") {
|
|
return "RandomInt64()";
|
|
} else if (arg.scalar_type() == "uint16_t") {
|
|
return "RandomUint16()";
|
|
} else if (arg.scalar_type() == "int16_t") {
|
|
return "RandomInt16()";
|
|
} else if (arg.scalar_type() == "uint8_t") {
|
|
return "RandomUint8()";
|
|
} else if (arg.scalar_type() == "int8_t") {
|
|
return "RandomInt8()";
|
|
} else if (arg.scalar_type() == "float_t") {
|
|
return "RandomFloat()";
|
|
} else if (arg.scalar_type() == "double_t") {
|
|
return "RandomDouble()";
|
|
} else if (arg.scalar_type() == "char_pointer") {
|
|
return "RandomCharPointer()";
|
|
} else if (arg.scalar_type() == "uchar_pointer") {
|
|
return "(unsigned char*) RandomCharPointer()";
|
|
} else if (arg.scalar_type() == "pointer" ||
|
|
arg.scalar_type() == "void_pointer") {
|
|
return "RandomVoidPointer()";
|
|
}
|
|
cerr << __FILE__ << ":" << __LINE__ << " "
|
|
<< "error: unsupported scalar data type " << arg.scalar_type() << endl;
|
|
exit(-1);
|
|
}
|
|
case TYPE_ENUM:
|
|
case TYPE_MASK: {
|
|
if (!arg.has_enum_value() && arg.has_predefined_type()) {
|
|
if (!message || message->component_class() != HAL_HIDL) {
|
|
return "(" + arg.predefined_type() + ") RandomUint32()";
|
|
} else {
|
|
std::string predefined_type_name = arg.predefined_type();
|
|
ReplaceSubString(predefined_type_name, "::", "__");
|
|
return "Random" + predefined_type_name + "()";
|
|
// TODO: generate a function which can dynamically choose the value.
|
|
/* for (const auto& attribute : message->attribute()) {
|
|
if (attribute.type() == TYPE_ENUM &&
|
|
attribute.name() == arg.predefined_type()) {
|
|
// TODO: pick at runtime
|
|
return message->component_name() + "::"
|
|
+ arg.predefined_type() + "::"
|
|
+ attribute.enum_value().enumerator(0);
|
|
}
|
|
} */
|
|
}
|
|
} else {
|
|
cerr << __func__
|
|
<< " ENUM either has enum value or doesn't have predefined type"
|
|
<< endl;
|
|
exit(-1);
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_STRING: {
|
|
return "android::hardware::hidl_string(RandomCharPointer())";
|
|
}
|
|
case TYPE_STRUCT: {
|
|
if (arg.struct_value_size() == 0 && arg.has_predefined_type()) {
|
|
return message->component_name() + "::" + arg.predefined_type() + "()";
|
|
}
|
|
break;
|
|
}
|
|
case TYPE_VECTOR: { // only for HAL_HIDL
|
|
// TODO: generate code that initializes a local hidl_vec.
|
|
return "";
|
|
}
|
|
case TYPE_HIDL_CALLBACK: {
|
|
return arg.predefined_type() + "()";
|
|
}
|
|
default:
|
|
break;
|
|
}
|
|
cerr << __func__ << ": error: unsupported type " << arg.type() << endl;
|
|
exit(-1);
|
|
}
|
|
|
|
int vts_fs_mkdirs(char* file_path, mode_t mode) {
|
|
char* p;
|
|
|
|
for (p = strchr(file_path + 1, '/'); p; p = strchr(p + 1, '/')) {
|
|
*p = '\0';
|
|
if (mkdir(file_path, mode) == -1) {
|
|
if (errno != EEXIST) {
|
|
*p = '/';
|
|
return -1;
|
|
}
|
|
}
|
|
*p = '/';
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
string ClearStringWithNameSpaceAccess(const string& str) {
|
|
string result = str;
|
|
ReplaceSubString(result, "::", "__");
|
|
return result;
|
|
}
|
|
|
|
// Returns a string which joins the given dir_path and file_name.
|
|
string PathJoin(const char* dir_path, const char* file_name) {
|
|
string result;
|
|
if (dir_path) {
|
|
result = dir_path;
|
|
if (!file_name) return result;
|
|
} else if (!file_name) return result;
|
|
|
|
if (file_name[0] != '.') {
|
|
if (result.c_str()[result.length()-1] != '/') {
|
|
result += "/";
|
|
}
|
|
}
|
|
result += file_name;
|
|
return result;
|
|
}
|
|
|
|
// Returns a string which remove given base_path from file_path if included.
|
|
string RemoveBaseDir(const string& file_path, const string& base_path) {
|
|
if (base_path.empty() ||
|
|
strncmp(file_path.c_str(), base_path.c_str(), base_path.length())) {
|
|
return file_path;
|
|
}
|
|
string result;
|
|
result = &file_path.c_str()[base_path.length()];
|
|
if (result.c_str()[0] == '/') {
|
|
result = &result.c_str()[1];
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string GetPackageName(const ComponentSpecificationMessage& message) {
|
|
if (!message.package().empty()) {
|
|
return message.package();
|
|
}
|
|
return "";
|
|
}
|
|
|
|
string GetPackagePath(const ComponentSpecificationMessage& message) {
|
|
string package_path = GetPackageName(message);
|
|
ReplaceSubString(package_path, ".", "/");
|
|
return package_path;
|
|
}
|
|
|
|
string GetPackageNamespaceToken(const ComponentSpecificationMessage& message) {
|
|
string package_token = GetPackageName(message);
|
|
ReplaceSubString(package_token, ".", "::");
|
|
return package_token;
|
|
}
|
|
|
|
string GetVersion(const ComponentSpecificationMessage& message,
|
|
bool for_macro) {
|
|
return GetVersionString(message.component_type_version_major(),
|
|
message.component_type_version_minor(), for_macro);
|
|
}
|
|
|
|
int GetMajorVersion(const ComponentSpecificationMessage& message) {
|
|
return message.component_type_version_major();
|
|
}
|
|
|
|
int GetMinorVersion(const ComponentSpecificationMessage& message) {
|
|
return message.component_type_version_minor();
|
|
}
|
|
|
|
string GetComponentBaseName(const ComponentSpecificationMessage& message) {
|
|
if (!message.component_name().empty()) {
|
|
return (message.component_name() == "types"
|
|
? "types"
|
|
: message.component_name().substr(1));
|
|
} else
|
|
return GetComponentName(message);
|
|
}
|
|
|
|
string GetComponentName(const ComponentSpecificationMessage& message) {
|
|
if (!message.component_name().empty()) {
|
|
return message.component_name();
|
|
}
|
|
|
|
string component_name = message.original_data_structure_name();
|
|
while (!component_name.empty()
|
|
&& (std::isspace(component_name.back()) || component_name.back() == '*')) {
|
|
component_name.pop_back();
|
|
}
|
|
const auto pos = component_name.find_last_of(" ");
|
|
if (pos != std::string::npos) {
|
|
component_name = component_name.substr(pos + 1);
|
|
}
|
|
return component_name;
|
|
}
|
|
|
|
FQName GetFQName(const ComponentSpecificationMessage& message) {
|
|
return FQName(message.package(),
|
|
GetVersionString(message.component_type_version_major(),
|
|
message.component_type_version_minor()),
|
|
GetComponentName(message));
|
|
}
|
|
|
|
string GetVarString(const string& var_name) {
|
|
string var_str = var_name;
|
|
for (size_t i = 0; i < var_name.length(); i++) {
|
|
if (!isdigit(var_str[i]) && !isalpha(var_str[i])) {
|
|
var_str[i] = '_';
|
|
}
|
|
}
|
|
return var_str;
|
|
}
|
|
|
|
} // namespace vts
|
|
} // namespace android
|