1 /*
2  * Copyright (C) 2024 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 #include "ringtone_language_manager_test.h"
16 
17 #include "ability_context_impl.h"
18 #include "rdb_helper.h"
19 #include "ringtone_errno.h"
20 #include "ringtone_type.h"
21 #include "ringtone_rdbstore.h"
22 #define private public
23 #include "ringtone_language_manager.h"
24 #undef private
25 
26 using namespace std;
27 using namespace OHOS;
28 using namespace testing::ext;
29 
30 namespace OHOS {
31 namespace Media {
32 
33 enum {
34     DATA_INDEX = 0,
35     DISPLAY_NAME_INDEX,
36     TITLE_INDEX,
37     SOURCE_TYPE_INDEX,
38     DISPLAY_LANGUAGE_TYPE_INDEX,
39 };
40 
41 static std::shared_ptr<RingtoneUnistore> g_ringtoneUniStore = nullptr;
42 const string RINGTONE_MULTILINGUAL_FILE_PATH  =
43     "/system/variant/phone/base/etc/resource/media/audio/ringtone_list_language.xml";
44 const std::vector<std::vector<std::string>> metadata = {
45     {"/sys_prod/resource/media/audio/alarms/candy.ogg", "candy.ogg", "糖果", "1", "zh-Hans"},
46     {"/sys_prod/resource/media/audio/alarms/spring_outing.ogg", "spring_outing.ogg", "春游", "1", "zh-Hans"},
47     {"/sys_prod/resource/media/audio/alarms/maze.ogg", "maze.ogg", "maze", "1", "en-Latn-US"},
48     {"/sys_prod/resource/media/audio/alarms/didi.ogg", "didi.ogg", "didi", "1", "en-Latn-US"},
49     {"/sys_prod/resource/media/audio/alarms/brook.ogg", "brook.ogg", "brook", "1", ""},
50     {"/sys_prod/resource/media/audio/alarms/kaleidoscope.ogg", "kaleidoscope.ogg", "kaleidoscope", "2", ""},
51 };
52 const std::map<std::string, std::map<std::string, std::string>> translationResources = {
53     {
54         "zh-Hans", {
55             {"candy", "糖果"},
56             {"spring_outing", "春游"},
57             {"maze", "迷宫"},
58             {"didi", "滴滴"},
59             {"brook", "溪流"},
60             {"kaleidoscope", "万花筒"},
61         }
62     },
63     {
64         "en-Latn-US", {
65             {"candy", "candy"},
66             {"spring_outing", "spring outing"},
67             {"maze", "maze"},
68             {"didi", "didi"},
69             {"brook", "brook"},
70             {"kaleidoscope", "kaleidoscope"},
71         }
72     }
73 };
74 const string CHINESE_ABBREVIATION = "zh-Hans";
75 const string ENGLISH_ABBREVIATION = "en-Latn-US";
76 const int32_t LANGUAGE_DIFF_AMOUNT = 3;
77 
78 void InitTestData();
79 
SetUpTestCase()80 void RingtoneLanguageManagerTest::SetUpTestCase() {}
81 
TearDownTestCase()82 void RingtoneLanguageManagerTest::TearDownTestCase() {}
83 
84 // SetUp:Execute before each test case
SetUp()85 void RingtoneLanguageManagerTest::SetUp()
86 {
87     auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
88     auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
89     abilityContextImpl->SetStageContext(stageContext);
90     g_ringtoneUniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
91     int32_t ret = g_ringtoneUniStore->Init();
92     EXPECT_EQ(ret, E_OK);
93     InitTestData();
94 }
95 
TearDown(void)96 void RingtoneLanguageManagerTest::TearDown(void) {}
97 
InitTestData()98 void InitTestData()
99 {
100     Uri uri(RINGTONE_PATH_URI);
101     RingtoneDataCommand cmdDel(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
102     int32_t rowId = 0;
103     int32_t ret = g_ringtoneUniStore->Delete(cmdDel, rowId);
104     EXPECT_EQ(ret, E_OK);
105 
106     for (auto &item : metadata) {
107         RingtoneDataCommand cmdInsert(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
108         NativeRdb::ValuesBucket values;
109         values.Put(RINGTONE_COLUMN_DATA, item[DATA_INDEX]);
110         values.Put(RINGTONE_COLUMN_DISPLAY_NAME, item[DISPLAY_NAME_INDEX]);
111         values.Put(RINGTONE_COLUMN_TITLE, item[TITLE_INDEX]);
112         values.Put(RINGTONE_COLUMN_SOURCE_TYPE, stoi(item[SOURCE_TYPE_INDEX]));
113         if (!item[DISPLAY_LANGUAGE_TYPE_INDEX].empty()) {
114             values.Put(RINGTONE_COLUMN_DISPLAY_LANGUAGE_TYPE, item[DISPLAY_LANGUAGE_TYPE_INDEX]);
115         }
116         cmdInsert.SetValueBucket(values);
117         int64_t rowId = E_HAS_DB_ERROR;
118         int32_t ret = g_ringtoneUniStore->Insert(cmdInsert, rowId);
119         EXPECT_EQ(ret, E_OK);
120     }
121 }
122 
123 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_001, TestSize.Level0)
124 {
125     auto langMgr = RingtoneLanguageManager::GetInstance();
126     langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
127 
128     int rowCount = 0;
129     std::shared_ptr<NativeRdb::ResultSet> resultSet;
130     int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
131     EXPECT_EQ(ret, E_OK);
132     EXPECT_EQ(rowCount, LANGUAGE_DIFF_AMOUNT);
133 }
134 
135 HWTEST_F(RingtoneLanguageManagerTest, languageManager_CheckLanguageTypeByRingtone_test_002, TestSize.Level0)
136 {
137     auto langMgr = RingtoneLanguageManager::GetInstance();
138     langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
139 
140     int rowCount = 0;
141     std::shared_ptr<NativeRdb::ResultSet> resultSet;
142     int ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
143     EXPECT_EQ(ret, E_OK);
144     EXPECT_EQ(rowCount, LANGUAGE_DIFF_AMOUNT);
145 }
146 
147 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_001, TestSize.Level0)
148 {
149     auto langMgr = RingtoneLanguageManager::GetInstance();
150     langMgr->systemLanguage_ = ENGLISH_ABBREVIATION;
151 
152     int rowCount = 0;
153     std::shared_ptr<NativeRdb::ResultSet> resultSet;
154     int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
155     EXPECT_EQ(ret, E_OK);
156     EXPECT_EQ(rowCount, LANGUAGE_DIFF_AMOUNT);
157 
158     langMgr->ringtoneTranslate_ = translationResources;
159     langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
160 
161     ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
162     EXPECT_EQ(ret, E_OK);
163     EXPECT_EQ(rowCount, 0);
164 }
165 
166 HWTEST_F(RingtoneLanguageManagerTest, languageManager_ChangeLanguageDataToRingtone_test_002, TestSize.Level0)
167 {
168     auto langMgr = RingtoneLanguageManager::GetInstance();
169     langMgr->systemLanguage_ = CHINESE_ABBREVIATION;
170 
171     int rowCount = 0;
172     std::shared_ptr<NativeRdb::ResultSet> resultSet;
173     int32_t ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
174     EXPECT_EQ(ret, E_OK);
175     EXPECT_EQ(rowCount, LANGUAGE_DIFF_AMOUNT);
176 
177     langMgr->ringtoneTranslate_ = translationResources;
178     langMgr->ChangeLanguageDataToRingtone(rowCount, resultSet);
179 
180     ret = langMgr->CheckLanguageTypeByRingtone(rowCount, resultSet);
181     EXPECT_EQ(ret, E_OK);
182     EXPECT_EQ(rowCount, 0);
183 }
184 } // namespace Media
185 } // namespace OHOS
186