1 /*
2 * Copyright (c) 2021-2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "hap_parser_test.h"
17
18 #include <gtest/gtest.h>
19
20 #include "test_common.h"
21 #include "utils/string_utils.h"
22
23 #define private public
24
25 #include "hap_parser.h"
26
27 using namespace OHOS::Global::Resource;
28 using namespace testing::ext;
29 namespace {
30 class HapParserTest : public testing::Test {
31 public:
32 static void SetUpTestCase(void);
33
34 static void TearDownTestCase(void);
35
36 void SetUp();
37
38 void TearDown();
39 };
40
SetUpTestCase(void)41 void HapParserTest::SetUpTestCase(void)
42 {
43 // step 1: input testsuit setup step
44 g_logLevel = LOG_DEBUG;
45 }
46
TearDownTestCase()47 void HapParserTest::TearDownTestCase()
48 {
49 // step 2: input testsuit teardown step
50 }
51
SetUp()52 void HapParserTest::SetUp()
53 {
54 // step 3: input testcase setup step
55 }
56
TearDown()57 void HapParserTest::TearDown()
58 {
59 // step 4: input testcase teardown step
60 }
61
62 /*
63 * @tc.name: HapParserFuncTest001
64 * @tc.desc: Test CreateResConfigFromKeyParams
65 * @tc.type: FUNC
66 */
67 HWTEST_F(HapParserTest, HapParserFuncTest001, TestSize.Level1)
68 {
69 std::vector<KeyParam *> keyParams;
70 auto kp = new KeyParam();
71 kp->type_ = LANGUAGES;
72 kp->value_ = 31336;
73 kp->InitStr();
74 keyParams.push_back(kp);
75 kp = new KeyParam();
76 kp->type_ = REGION;
77 kp->value_ = 17230;
78 kp->InitStr();
79 keyParams.push_back(kp);
80 kp = new KeyParam();
81 kp->type_ = SCREEN_DENSITY;
82 kp->value_ = SCREEN_DENSITY_SDPI;
83 kp->InitStr();
84 keyParams.push_back(kp);
85 kp = new KeyParam();
86 kp->type_ = DEVICETYPE;
87 kp->value_ = DEVICE_CAR;
88 kp->InitStr();
89 keyParams.push_back(kp);
90 kp = new KeyParam();
91 kp->type_ = DIRECTION;
92 kp->value_ = DIRECTION_VERTICAL;
93 kp->InitStr();
94 keyParams.push_back(kp);
95 auto config = HapParser::CreateResConfigFromKeyParams(keyParams);
96 if (config != nullptr) {
97 EXPECT_EQ(std::string("zh"), config->GetLocaleInfo()->GetLanguage());
98 EXPECT_EQ(std::string("CN"), config->GetLocaleInfo()->GetRegion());
99 EXPECT_EQ(std::string("Hans"), config->GetLocaleInfo()->GetScript());
100 EXPECT_EQ(DEVICE_CAR, config->GetDeviceType());
101 EXPECT_EQ(DIRECTION_VERTICAL, config->GetDirection());
102 EXPECT_EQ(SCREEN_DENSITY_SDPI, config->GetScreenDensity());
103 } else {
104 EXPECT_TRUE(false);
105 }
106
107 for (auto kp = keyParams.begin(); kp != keyParams.end(); kp++) {
108 delete *kp;
109 }
110 delete config;
111 }
112
113 /*
114 * @tc.name: HapParserFuncTest002
115 * @tc.desc: Test GetDeviceType
116 * @tc.type: FUNC
117 */
118 HWTEST_F(HapParserTest, HapParserFuncTest002, TestSize.Level1)
119 {
120 ASSERT_EQ(DEVICE_CAR, HapParser::GetDeviceType(DEVICE_CAR));
121 ASSERT_EQ(DEVICE_PAD, HapParser::GetDeviceType(DEVICE_PAD));
122 ASSERT_EQ(DEVICE_PHONE, HapParser::GetDeviceType(DEVICE_PHONE));
123 ASSERT_EQ(DEVICE_TABLET, HapParser::GetDeviceType(DEVICE_TABLET));
124 ASSERT_EQ(DEVICE_TV, HapParser::GetDeviceType(DEVICE_TV));
125 ASSERT_EQ(DEVICE_WEARABLE, HapParser::GetDeviceType(DEVICE_WEARABLE));
126 ASSERT_EQ(DEVICE_NOT_SET, HapParser::GetDeviceType(1000000));
127 }
128
129 /*
130 * @tc.name: HapParserFuncTest003
131 * @tc.desc: Test GetScreenDensity
132 * @tc.type: FUNC
133 */
134 HWTEST_F(HapParserTest, HapParserFuncTest003, TestSize.Level1)
135 {
136 ASSERT_EQ(SCREEN_DENSITY_SDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_SDPI));
137 ASSERT_EQ(SCREEN_DENSITY_MDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_MDPI));
138 ASSERT_EQ(SCREEN_DENSITY_LDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_LDPI));
139 ASSERT_EQ(SCREEN_DENSITY_XLDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_XLDPI));
140 ASSERT_EQ(SCREEN_DENSITY_XXLDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_XXLDPI));
141 ASSERT_EQ(SCREEN_DENSITY_XXXLDPI, HapParser::GetScreenDensity(SCREEN_DENSITY_XXXLDPI));
142 ASSERT_EQ(SCREEN_DENSITY_NOT_SET, HapParser::GetScreenDensity(10000000));
143 }
144
145 /*
146 * @tc.name: HapParserFuncTest004
147 * @tc.desc: Test ToFolderPath
148 * @tc.type: FUNC
149 */
150 HWTEST_F(HapParserTest, HapParserFuncTest004, TestSize.Level1)
151 {
152 std::vector<KeyParam *> keyParams;
153 auto kp = new KeyParam();
154 kp->type_ = LANGUAGES;
155 kp->value_ = 31336;
156 kp->InitStr();
157 keyParams.push_back(kp);
158 kp = new KeyParam();
159 kp->type_ = REGION;
160 kp->value_ = 17230;
161 kp->InitStr();
162 keyParams.push_back(kp);
163 kp = new KeyParam();
164 kp->type_ = SCREEN_DENSITY;
165 kp->value_ = SCREEN_DENSITY_SDPI;
166 kp->InitStr();
167 keyParams.push_back(kp);
168 kp = new KeyParam();
169 kp->type_ = DEVICETYPE;
170 kp->value_ = DEVICE_CAR;
171 kp->InitStr();
172 keyParams.push_back(kp);
173 kp = new KeyParam();
174 kp->type_ = DIRECTION;
175 kp->value_ = DIRECTION_VERTICAL;
176 kp->InitStr();
177 keyParams.push_back(kp);
178 std::string folder = HapParser::ToFolderPath(keyParams);
179 ASSERT_EQ("zh_CN-vertical-car-sdpi", folder);
180 for (auto kp = keyParams.begin(); kp != keyParams.end(); kp++) {
181 delete *kp;
182 }
183 }
184 }