1/*
2 * Copyright (C) 2015 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "StringPool.h"
18#include "util/Util.h"
19
20#include <gtest/gtest.h>
21#include <string>
22
23namespace aapt {
24
25TEST(StringPoolTest, InsertOneString) {
26    StringPool pool;
27
28    StringPool::Ref ref = pool.makeRef(u"wut");
29    EXPECT_EQ(*ref, u"wut");
30}
31
32TEST(StringPoolTest, InsertTwoUniqueStrings) {
33    StringPool pool;
34
35    StringPool::Ref ref = pool.makeRef(u"wut");
36    StringPool::Ref ref2 = pool.makeRef(u"hey");
37
38    EXPECT_EQ(*ref, u"wut");
39    EXPECT_EQ(*ref2, u"hey");
40}
41
42TEST(StringPoolTest, DoNotInsertNewDuplicateString) {
43    StringPool pool;
44
45    StringPool::Ref ref = pool.makeRef(u"wut");
46    StringPool::Ref ref2 = pool.makeRef(u"wut");
47
48    EXPECT_EQ(*ref, u"wut");
49    EXPECT_EQ(*ref2, u"wut");
50    EXPECT_EQ(1u, pool.size());
51}
52
53TEST(StringPoolTest, MaintainInsertionOrderIndex) {
54    StringPool pool;
55
56    StringPool::Ref ref = pool.makeRef(u"z");
57    StringPool::Ref ref2 = pool.makeRef(u"a");
58    StringPool::Ref ref3 = pool.makeRef(u"m");
59
60    EXPECT_EQ(0u, ref.getIndex());
61    EXPECT_EQ(1u, ref2.getIndex());
62    EXPECT_EQ(2u, ref3.getIndex());
63}
64
65TEST(StringPoolTest, PruneStringsWithNoReferences) {
66    StringPool pool;
67
68    StringPool::Ref refA = pool.makeRef(u"foo");
69    {
70        StringPool::Ref ref = pool.makeRef(u"wut");
71        EXPECT_EQ(*ref, u"wut");
72        EXPECT_EQ(2u, pool.size());
73    }
74    StringPool::Ref refB = pool.makeRef(u"bar");
75
76    EXPECT_EQ(3u, pool.size());
77    pool.prune();
78    EXPECT_EQ(2u, pool.size());
79    StringPool::const_iterator iter = begin(pool);
80    EXPECT_EQ((*iter)->value, u"foo");
81    EXPECT_LT((*iter)->index, 2u);
82    ++iter;
83    EXPECT_EQ((*iter)->value, u"bar");
84    EXPECT_LT((*iter)->index, 2u);
85}
86
87TEST(StringPoolTest, SortAndMaintainIndexesInReferences) {
88    StringPool pool;
89
90    StringPool::Ref ref = pool.makeRef(u"z");
91    StringPool::StyleRef ref2 = pool.makeRef(StyleString{ {u"a"} });
92    StringPool::Ref ref3 = pool.makeRef(u"m");
93
94    EXPECT_EQ(*ref, u"z");
95    EXPECT_EQ(0u, ref.getIndex());
96
97    EXPECT_EQ(*(ref2->str), u"a");
98    EXPECT_EQ(1u, ref2.getIndex());
99
100    EXPECT_EQ(*ref3, u"m");
101    EXPECT_EQ(2u, ref3.getIndex());
102
103    pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
104        return a.value < b.value;
105    });
106
107
108    EXPECT_EQ(*ref, u"z");
109    EXPECT_EQ(2u, ref.getIndex());
110
111    EXPECT_EQ(*(ref2->str), u"a");
112    EXPECT_EQ(0u, ref2.getIndex());
113
114    EXPECT_EQ(*ref3, u"m");
115    EXPECT_EQ(1u, ref3.getIndex());
116}
117
118TEST(StringPoolTest, SortAndStillDedupe) {
119    StringPool pool;
120
121    StringPool::Ref ref = pool.makeRef(u"z");
122    StringPool::Ref ref2 = pool.makeRef(u"a");
123    StringPool::Ref ref3 = pool.makeRef(u"m");
124
125    pool.sort([](const StringPool::Entry& a, const StringPool::Entry& b) -> bool {
126        return a.value < b.value;
127    });
128
129    StringPool::Ref ref4 = pool.makeRef(u"z");
130    StringPool::Ref ref5 = pool.makeRef(u"a");
131    StringPool::Ref ref6 = pool.makeRef(u"m");
132
133    EXPECT_EQ(ref4.getIndex(), ref.getIndex());
134    EXPECT_EQ(ref5.getIndex(), ref2.getIndex());
135    EXPECT_EQ(ref6.getIndex(), ref3.getIndex());
136}
137
138TEST(StringPoolTest, AddStyles) {
139    StringPool pool;
140
141    StyleString str {
142        { u"android" },
143        {
144            Span{ { u"b" }, 2, 6 }
145        }
146    };
147
148    StringPool::StyleRef ref = pool.makeRef(str);
149
150    EXPECT_EQ(0u, ref.getIndex());
151    EXPECT_EQ(std::u16string(u"android"), *(ref->str));
152    ASSERT_EQ(1u, ref->spans.size());
153
154    const StringPool::Span& span = ref->spans.front();
155    EXPECT_EQ(*(span.name), u"b");
156    EXPECT_EQ(2u, span.firstChar);
157    EXPECT_EQ(6u, span.lastChar);
158}
159
160TEST(StringPoolTest, DoNotDedupeStyleWithSameStringAsNonStyle) {
161    StringPool pool;
162
163    StringPool::Ref ref = pool.makeRef(u"android");
164
165    StyleString str { { u"android" } };
166    StringPool::StyleRef styleRef = pool.makeRef(str);
167
168    EXPECT_NE(ref.getIndex(), styleRef.getIndex());
169}
170
171TEST(StringPoolTest, FlattenEmptyStringPoolUtf8) {
172    using namespace android; // For NO_ERROR on Windows.
173
174    StringPool pool;
175    BigBuffer buffer(1024);
176    StringPool::flattenUtf8(&buffer, pool);
177
178    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
179    ResStringPool test;
180    ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
181}
182
183TEST(StringPoolTest, FlattenOddCharactersUtf16) {
184    using namespace android; // For NO_ERROR on Windows.
185
186    StringPool pool;
187    pool.makeRef(u"\u093f");
188    BigBuffer buffer(1024);
189    StringPool::flattenUtf16(&buffer, pool);
190
191    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
192    ResStringPool test;
193    ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
194    size_t len = 0;
195    const char16_t* str = test.stringAt(0, &len);
196    EXPECT_EQ(1u, len);
197    EXPECT_EQ(u'\u093f', *str);
198    EXPECT_EQ(0u, str[1]);
199}
200
201constexpr const char16_t* sLongString = u"バッテリーを長持ちさせるため、バッテリーセーバーは端末のパフォーマンスを抑え、バイブレーション、位置情報サービス、大半のバックグラウンドデータを制限します。メール、SMSや、同期を使 用するその他のアプリは、起動しても更新されないことがあります。バッテリーセーバーは端末の充電中は自動的にOFFになります。";
202
203TEST(StringPoolTest, FlattenUtf8) {
204    using namespace android; // For NO_ERROR on Windows.
205
206    StringPool pool;
207
208    StringPool::Ref ref1 = pool.makeRef(u"hello");
209    StringPool::Ref ref2 = pool.makeRef(u"goodbye");
210    StringPool::Ref ref3 = pool.makeRef(sLongString);
211    StringPool::StyleRef ref4 = pool.makeRef(StyleString{
212            { u"style" },
213            { Span{ { u"b" }, 0, 1 }, Span{ { u"i" }, 2, 3 } }
214    });
215
216    EXPECT_EQ(0u, ref1.getIndex());
217    EXPECT_EQ(1u, ref2.getIndex());
218    EXPECT_EQ(2u, ref3.getIndex());
219    EXPECT_EQ(3u, ref4.getIndex());
220
221    BigBuffer buffer(1024);
222    StringPool::flattenUtf8(&buffer, pool);
223
224    std::unique_ptr<uint8_t[]> data = util::copy(buffer);
225    {
226        ResStringPool test;
227        ASSERT_EQ(test.setTo(data.get(), buffer.size()), NO_ERROR);
228
229        EXPECT_EQ(util::getString(test, 0), u"hello");
230        EXPECT_EQ(util::getString(test, 1), u"goodbye");
231        EXPECT_EQ(util::getString(test, 2), sLongString);
232        EXPECT_EQ(util::getString(test, 3), u"style");
233
234        const ResStringPool_span* span = test.styleAt(3);
235        ASSERT_NE(nullptr, span);
236        EXPECT_EQ(util::getString(test, span->name.index), u"b");
237        EXPECT_EQ(0u, span->firstChar);
238        EXPECT_EQ(1u, span->lastChar);
239        span++;
240
241        ASSERT_NE(ResStringPool_span::END, span->name.index);
242        EXPECT_EQ(util::getString(test, span->name.index), u"i");
243        EXPECT_EQ(2u, span->firstChar);
244        EXPECT_EQ(3u, span->lastChar);
245        span++;
246
247        EXPECT_EQ(ResStringPool_span::END, span->name.index);
248    }
249}
250
251} // namespace aapt
252