From f93d34d6a3698ec94e8775c03c9f9966b1290a15 Mon Sep 17 00:00:00 2001 From: wangchao582 Date: Sun, 5 Nov 2023 14:20:15 +0800 Subject: [PATCH] Add hdi test suites -light Signed-off-by: wangchao582 --- hdf/light/BUILD.gn | 2 +- hdf/light/hdiService_additional/BUILD.gn | 52 ++ .../HdfLightCommonTestAdditional.cpp | 498 ++++++++++++++++++ hdf/light/hdiService_additional/Test.json | 18 + 4 files changed, 569 insertions(+), 1 deletion(-) create mode 100644 hdf/light/hdiService_additional/BUILD.gn create mode 100644 hdf/light/hdiService_additional/HdfLightCommonTestAdditional.cpp create mode 100644 hdf/light/hdiService_additional/Test.json diff --git a/hdf/light/BUILD.gn b/hdf/light/BUILD.gn index ddfe5a0f..b5ea03a4 100644 --- a/hdf/light/BUILD.gn +++ b/hdf/light/BUILD.gn @@ -22,8 +22,8 @@ group("HatsHdfLightTest") { deps = [ #"liteos:HatsHdfLightHdiTest", "hdiService:HatsHdfLightCommonTest", + "hdiService_additional:HatsHdfLightCommonTestAdditional", "hdiService:HatsHdfLightServiceTest", - #"lightBenchmarkTest:HatsHdfLightbenchmarkTest", ] } diff --git a/hdf/light/hdiService_additional/BUILD.gn b/hdf/light/hdiService_additional/BUILD.gn new file mode 100644 index 00000000..cfa407a7 --- /dev/null +++ b/hdf/light/hdiService_additional/BUILD.gn @@ -0,0 +1,52 @@ +# Copyright (c) 2021-2022 Huawei Device Co., Ltd. +# 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. + +base_root = "../../../../../../" +import("//build/ohos_var.gni") +import("//test/xts/tools/build/suite.gni") +import("$base_root/drivers/hdf_core/adapter/uhdf2/uhdf.gni") + +module_output_path = "hats/light" +ohos_moduletest_suite("HatsHdfLightCommonTestAdditional") { + module_out_path = module_output_path + + configs = [ ":hdf_light_common_additional" ] + + sources = [ "HdfLightCommonTestAdditional.cpp" ] + + cflags = [ + "-Wall", + "-Wextra", + "-Werror", + "-fsigned-char", + "-fno-common", + "-fno-strict-aliasing", + ] + + if (is_standard_system) { + external_deps = [ + "c_utils:utils", + "drivers_interface_light:liblight_proxy_1.0", + "hdf_core:libhdf_utils", + "hilog:libhilog", + "ipc:ipc_single", + ] + } else { + external_deps = [ "hilog:libhilog" ] + } + external_deps += [ "ipc:ipc_single" ] +} + +config("hdf_light_common_additional") { + include_dirs = [ "$base_root/drivers/peripheral/light/interfaces/include" ] +} \ No newline at end of file diff --git a/hdf/light/hdiService_additional/HdfLightCommonTestAdditional.cpp b/hdf/light/hdiService_additional/HdfLightCommonTestAdditional.cpp new file mode 100644 index 00000000..6d908316 --- /dev/null +++ b/hdf/light/hdiService_additional/HdfLightCommonTestAdditional.cpp @@ -0,0 +1,498 @@ +/* + * Copyright (c) 2023 Huawei Device Co., Ltd. + * 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 "hdf_base.h" +#include "light_type.h" +#include "osal_time.h" +#include "v1_0/ilight_interface.h" +#include +#include +#include +#include + +using namespace OHOS::HDI::Light::V1_0; +using namespace testing::ext; + +namespace { +constexpr uint32_t SLEEPTIME = 3; +constexpr int32_t MIN_VALUE = 0; +constexpr int32_t MAX_VALUE = 255; +std::vector g_info; +sptr g_lightInterface = nullptr; + +class HatsHdfLightCommonTestAdditional : public testing::Test { +public: + static void SetUpTestCase(); + static void TearDownTestCase(); + void SetUp(); + void TearDown(); +}; + +void HatsHdfLightCommonTestAdditional::SetUpTestCase() { g_lightInterface = ILightInterface::Get(); } + +void HatsHdfLightCommonTestAdditional::TearDownTestCase() {} + +void HatsHdfLightCommonTestAdditional::SetUp() {} + +void HatsHdfLightCommonTestAdditional::TearDown() {} + +void InitConfig(HdfLightEffect &effect) +{ + effect.lightColor.colorValue.rgbColor.r = MIN_VALUE; + effect.lightColor.colorValue.rgbColor.g = MIN_VALUE; + effect.lightColor.colorValue.rgbColor.b = MIN_VALUE; + effect.flashEffect.flashMode = HDF_LIGHT_FLASH_NONE; + effect.flashEffect.onTime = 1; + effect.flashEffect.offTime = 1; +} + +/* * + * @tc.number: SUB_Driver_Light_GetlightInfo_0200 + * @tc.name : testhdiServiceGetLightInfoTimes001 + * @tc.desc : Get light info 10times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceGetLightInfoTimes001, Function | MediumTest | Level1) +{ + int32_t ret; + + ASSERT_NE(nullptr, g_lightInterface); + + for (int i = 0; i <= 10; i++) { + ret = g_lightInterface->GetLightInfo(g_info); + EXPECT_EQ(HDF_SUCCESS, ret); + EXPECT_GT(g_info.size(), 0); + printf("get light list num[%zu]\n\r", g_info.size()); + + for (auto iter : g_info) { + printf("lightId[%d], lightName[%s], lightNumber[%d]\n\r", iter.lightId, iter.lightName.c_str(), + iter.lightNumber); + } + } +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_0500 + * @tc.name : testhdiServiceTurnOnLightMAX001 + * @tc.desc : Enter the minimum excess value to turn on the red light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightMAX001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.r = MAX_VALUE; + effect.lightColor.colorValue.rgbColor.g = MAX_VALUE; + effect.lightColor.colorValue.rgbColor.b = MAX_VALUE; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_0600 + * @tc.name : testhdiServiceTurnOnLightRedMAX001 + * @tc.desc : Enter the maximum excess value to turn on the red light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightRedMAX001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.r = MAX_VALUE; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_0700 + * @tc.name : testhdiServiceTurnOnLightRedMAXTimes001 + * @tc.desc : Turn on the light and it's always red 10 times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightRedMAXTimes001, Function | MediumTest | Level1) +{ + int32_t ret; + + ASSERT_NE(nullptr, g_lightInterface); + + for (int i = 0; i <= 10; i++) { + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.r = MAX_VALUE; + ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); + } +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_0800 + * @tc.name : testhdiServiceTurnOnLightGreenMAX001 + * @tc.desc : Enter the maximum excess value to turn on the green light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightGreenMAX001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.g = MAX_VALUE; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_0900 + * @tc.name : testhdiServiceTurnOnLightGreenMAXTimes001 + * @tc.desc : Turn on the light and it's always green 10 times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightGreenMAXTimes001, Function | MediumTest | Level1) +{ + int32_t ret; + ASSERT_NE(nullptr, g_lightInterface); + + for (int i = 0; i <= 10; i++) { + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.g = MAX_VALUE; + ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); + } +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1000 + * @tc.name : testhdiServiceTurnOnLightBlueMAX001 + * @tc.desc : Enter the maximum excess value to turn on the blue light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightBlueMAX001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.b = MAX_VALUE; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1100 + * @tc.name : testhdiServiceTurnOnLightBlueMAXTimes001 + * @tc.desc : Turn on the light and it's always blue 10 times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightBlueMAXTimes001, Function | MediumTest | Level1) +{ + int32_t ret; + ASSERT_NE(nullptr, g_lightInterface); + + for (int i = 0; i <= 10; i++) { + HdfLightEffect effect; + InitConfig(effect); + effect.lightColor.colorValue.rgbColor.b = MAX_VALUE; + ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); + } +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1200 + * @tc.name : testhdiServiceTurnOnLightFM001 + * @tc.desc : The input is Abnormal flashmode. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightFM001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.flashEffect.flashMode = 0; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1300 + * @tc.name : testhdiServiceTurnOnLightTime001 + * @tc.desc : Turn on the light Abnormal times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightTime001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.flashEffect.onTime = -1; + effect.flashEffect.offTime = 10; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1400 + * @tc.name : testhdiServiceTurnOnLightTime002 + * @tc.desc : Turn on the light Abnormal times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightTime002, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.flashEffect.onTime = 10; + effect.flashEffect.offTime = -1; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1500 + * @tc.name : testhdiServiceTurnOnLightTime003 + * @tc.desc : Turn on the light times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightTime003, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.flashEffect.onTime = 256; + effect.flashEffect.offTime = 0; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnLight_1600 + * @tc.name : testhdiServiceTurnOnLightTime004 + * @tc.desc : Turn on the light times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnLightTime004, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + HdfLightEffect effect; + InitConfig(effect); + effect.flashEffect.onTime = 0; + effect.flashEffect.offTime = 256; + + int32_t ret = g_lightInterface->TurnOnLight(g_info[0].lightId, effect); + EXPECT_EQ(HDF_SUCCESS, ret); + + ret = g_lightInterface->TurnOffLight(g_info[0].lightId); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnMultiLights_0200 + * @tc.name : testhdiServiceTurnOnMultiLightsRedMAX001 + * @tc.desc : Turn on the light Abnormal lightid. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnMultiLightsRedMAX001, Function | MediumTest | Level2) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BATTERY, lightColor); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_NOTIFICATIONS); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOnMultiLights_0300 + * @tc.name : testhdiServiceTurnOnMultiLightsTimes001 + * @tc.desc : Turn on the light lightid 10 times. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOnMultiLightsTimes001, Function | MediumTest | Level1) +{ + int32_t ret; + + ASSERT_NE(nullptr, g_lightInterface); + for (int i = 0; i <= 10; i++) { + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + light.colorValue.rgbColor.g = MIN_VALUE; + light.colorValue.rgbColor.b = MIN_VALUE; + lightColor.push_back(light); + ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BATTERY, lightColor); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_BATTERY); + EXPECT_EQ(HDF_SUCCESS, ret); + } +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOffLight_0100 + * @tc.name : testhdiServiceTurnOffBattery001 + * @tc.desc : Turn Off Light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOffBattery001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BATTERY, lightColor); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_BATTERY); + EXPECT_EQ(HDF_SUCCESS, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOffLight_0200 + * @tc.name : testhdiServiceTurnOffNotifications001 + * @tc.desc : Turn Off Light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOffNotifications001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BATTERY, lightColor); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_NOTIFICATIONS); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOffLight_0300 + * @tc.name : testhdiServiceTurnOffAttention001 + * @tc.desc : Turn Off Light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOffAttention001, Function | MediumTest | Level1) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BATTERY, lightColor); + EXPECT_EQ(HDF_SUCCESS, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_ATTENTION); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOffLight_0400 + * @tc.name : testhdiServiceTurnOffButt001 + * @tc.desc : Turn Off Light. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOffButt001, Function | MediumTest | Level2) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOnMultiLights(HDF_LIGHT_ID_BUTT, lightColor); + EXPECT_EQ(-2, ret); + OsalSleep(SLEEPTIME); + + ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_BUTT); + EXPECT_EQ(HDF_FAILURE, ret); +} + +/* * + * @tc.number: SUB_Driver_Light_TurnOffLight_0500 + * @tc.name : testhdiServiceTurnOffNoOn001 + * @tc.desc : Turn it off when it's not on. + */ +HWTEST_F(HatsHdfLightCommonTestAdditional, testhdiServiceTurnOffNoOn001, Function | MediumTest | Level2) +{ + ASSERT_NE(nullptr, g_lightInterface); + + std::vector lightColor; + struct HdfLightColor light; + light.colorValue.rgbColor.r = MAX_VALUE; + lightColor.push_back(light); + + int32_t ret = g_lightInterface->TurnOffLight(HDF_LIGHT_ID_BUTT); + EXPECT_EQ(HDF_FAILURE, ret); +} +} // namespace \ No newline at end of file diff --git a/hdf/light/hdiService_additional/Test.json b/hdf/light/hdiService_additional/Test.json new file mode 100644 index 00000000..7b217ab8 --- /dev/null +++ b/hdf/light/hdiService_additional/Test.json @@ -0,0 +1,18 @@ +{ + "kits": [ + { + "push": [ + "HatsHdfLightCommonTestAdditional->/data/local/tmp/HatsHdfLightCommonTestAdditional" + ], + "type": "PushKit" + } + ], + "driver": { + "native-test-timeout": "120000", + "type": "CppTest", + "module-name": "HatsHdfLightCommonTestAdditional", + "runtime-hint": "1s", + "native-test-device-path": "/data/local/tmp" + }, + "description": "Configuration for HatsHdfLightCommonTestAdditional Tests" +} \ No newline at end of file