Backfill some FX StringC unit tests for == and !=.
[pdfium.git] / core / src / fxcrt / fx_basic_wstring_unittest.cpp
1 // Copyright 2014 PDFium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 #include "testing/gtest/include/gtest/gtest.h"
6 #include "../../../testing/fx_string_testhelpers.h"
7 #include "../../include/fxcrt/fx_basic.h"
8
9 TEST(fxcrt, WideStringOperatorSubscript) {
10     // CFX_WideString includes the NUL terminator for non-empty strings.
11     CFX_WideString abc(L"abc");
12     EXPECT_EQ(L'a', abc[0]);
13     EXPECT_EQ(L'b', abc[1]);
14     EXPECT_EQ(L'c', abc[2]);
15     EXPECT_EQ(L'\0', abc[3]);
16 }
17
18 TEST(fxcrt, WideStringOperatorLT) {
19     CFX_WideString empty;
20     CFX_WideString a(L"a");
21     CFX_WideString abc(L"\x0110qq");  // Comes before despite endianness.
22     CFX_WideString def(L"\x1001qq");  // Comes after despite endianness.
23
24     EXPECT_FALSE(empty < empty);
25     EXPECT_FALSE(a < a);
26     EXPECT_FALSE(abc < abc);
27     EXPECT_FALSE(def < def);
28
29     EXPECT_TRUE(empty < a);
30     EXPECT_FALSE(a < empty);
31
32     EXPECT_TRUE(empty < abc);
33     EXPECT_FALSE(abc < empty);
34
35     EXPECT_TRUE(empty < def);
36     EXPECT_FALSE(def < empty);
37
38     EXPECT_TRUE(a < abc);
39     EXPECT_FALSE(abc < a);
40
41     EXPECT_TRUE(a < def);
42     EXPECT_FALSE(def < a);
43
44     EXPECT_TRUE(abc < def);
45     EXPECT_FALSE(def < abc);
46 }
47
48 TEST(fxcrt, WideStringOperatorEQ) {
49     CFX_WideString wide_string(L"hello");
50     ASSERT_TRUE(wide_string == wide_string);
51
52     CFX_WideString wide_string_same1(L"hello");
53     ASSERT_TRUE(wide_string == wide_string_same1);
54     ASSERT_TRUE(wide_string_same1 == wide_string);
55
56     CFX_WideString wide_string_same2(wide_string);
57     ASSERT_TRUE(wide_string == wide_string_same2);
58     ASSERT_TRUE(wide_string_same2 == wide_string);
59
60     CFX_WideString wide_string1(L"he");
61     CFX_WideString wide_string2(L"hellp");
62     CFX_WideString wide_string3(L"hellod");
63     ASSERT_FALSE(wide_string == wide_string1);
64     ASSERT_FALSE(wide_string == wide_string2);
65     ASSERT_FALSE(wide_string == wide_string3);
66     ASSERT_FALSE(wide_string1 == wide_string);
67     ASSERT_FALSE(wide_string2 == wide_string);
68     ASSERT_FALSE(wide_string3 == wide_string);
69
70     CFX_WideStringC wide_string_c_same1(L"hello");
71     ASSERT_TRUE(wide_string == wide_string_c_same1);
72     ASSERT_TRUE(wide_string_c_same1 == wide_string);
73
74     CFX_WideStringC wide_string_c1(L"he");
75     CFX_WideStringC wide_string_c2(L"hellp");
76     CFX_WideStringC wide_string_c3(L"hellod");
77     ASSERT_FALSE(wide_string == wide_string_c1);
78     ASSERT_FALSE(wide_string == wide_string_c2);
79     ASSERT_FALSE(wide_string == wide_string_c3);
80     ASSERT_FALSE(wide_string_c1 == wide_string);
81     ASSERT_FALSE(wide_string_c2 == wide_string);
82     ASSERT_FALSE(wide_string_c3 == wide_string);
83
84     const wchar_t* c_string_same1 = L"hello";
85     ASSERT_TRUE(wide_string == c_string_same1);
86 #if 0
87     // TODO(tsepez): Missing operator - there's a prototype but no actual
88     // implementation (at least we already removed implicit c_str() casting).
89     ASSERT_TRUE(c_string_same1 == wide_string);
90 #endif
91
92     const wchar_t* c_string1 = L"he";
93     const wchar_t* c_string2 = L"hellp";
94     const wchar_t* c_string3 = L"hellod";
95     ASSERT_FALSE(wide_string == c_string1);
96     ASSERT_FALSE(wide_string == c_string2);
97     ASSERT_FALSE(wide_string == c_string3);
98 #if 0
99     // See above TODO.
100     ASSERT_FALSE(c_string1 == wide_string);
101     ASSERT_FALSE(c_string2 == wide_string);
102     ASSERT_FALSE(c_string3 == wide_string);
103 #endif
104 }
105
106 TEST(fxcrt, WideStringOperatorNE) {
107     CFX_WideString wide_string(L"hello");
108     ASSERT_FALSE(wide_string != wide_string);
109
110     CFX_WideString wide_string_same1(L"hello");
111     ASSERT_FALSE(wide_string != wide_string_same1);
112     ASSERT_FALSE(wide_string_same1 != wide_string);
113
114     CFX_WideString wide_string_same2(wide_string);
115     ASSERT_FALSE(wide_string != wide_string_same2);
116     ASSERT_FALSE(wide_string_same2 != wide_string);
117
118     CFX_WideString wide_string1(L"he");
119     CFX_WideString wide_string2(L"hellp");
120     CFX_WideString wide_string3(L"hellod");
121     ASSERT_TRUE(wide_string != wide_string1);
122     ASSERT_TRUE(wide_string != wide_string2);
123     ASSERT_TRUE(wide_string != wide_string3);
124     ASSERT_TRUE(wide_string1 != wide_string);
125     ASSERT_TRUE(wide_string2 != wide_string);
126     ASSERT_TRUE(wide_string3 != wide_string);
127
128     CFX_WideStringC wide_string_c_same1(L"hello");
129     ASSERT_FALSE(wide_string != wide_string_c_same1);
130     ASSERT_FALSE(wide_string_c_same1 != wide_string);
131
132     CFX_WideStringC wide_string_c1(L"he");
133     CFX_WideStringC wide_string_c2(L"hellp");
134     CFX_WideStringC wide_string_c3(L"hellod");
135     ASSERT_TRUE(wide_string != wide_string_c1);
136     ASSERT_TRUE(wide_string != wide_string_c2);
137     ASSERT_TRUE(wide_string != wide_string_c3);
138     ASSERT_TRUE(wide_string_c1 != wide_string);
139     ASSERT_TRUE(wide_string_c2 != wide_string);
140     ASSERT_TRUE(wide_string_c3 != wide_string);
141
142     const wchar_t* c_string_same1 = L"hello";
143     ASSERT_FALSE(wide_string != c_string_same1);
144 #if 0
145     // See above TODO.
146     ASSERT_FALSE(c_string_same1 != wide_string);
147 #endif
148     const wchar_t* c_string1 = L"he";
149     const wchar_t* c_string2 = L"hellp";
150     const wchar_t* c_string3 = L"hellod";
151     ASSERT_TRUE(wide_string != c_string1);
152     ASSERT_TRUE(wide_string != c_string2);
153     ASSERT_TRUE(wide_string != c_string3);
154 #if 0
155     // See above TODO.
156     ASSERT_TRUE(c_string1 != wide_string);
157     ASSERT_TRUE(c_string2 != wide_string);
158     ASSERT_TRUE(c_string3 != wide_string);
159 #endif
160 }
161
162 #define ByteStringLiteral(str) CFX_ByteString(FX_BSTRC(str))
163
164 TEST(fxcrt, WideStringUTF16LE_Encode) {
165   struct UTF16LEEncodeCase {
166     CFX_WideString ws;
167     CFX_ByteString bs;
168   } utf16le_encode_cases[] = {
169     { L"", ByteStringLiteral("\0\0") },
170     { L"abc", ByteStringLiteral("a\0b\0c\0\0\0") },
171     { L"abcdef", ByteStringLiteral("a\0b\0c\0d\0e\0f\0\0\0") },
172     { L"abc\0def", ByteStringLiteral("a\0b\0c\0\0\0") },
173     { L"\xaabb\xccdd", ByteStringLiteral("\xbb\xaa\xdd\xcc\0\0") },
174     { L"\x3132\x6162", ByteStringLiteral("\x32\x31\x62\x61\0\0") },
175   };
176
177   for (size_t i = 0; i < FX_ArraySize(utf16le_encode_cases); ++i) {
178     EXPECT_EQ(utf16le_encode_cases[i].bs,
179         utf16le_encode_cases[i].ws.UTF16LE_Encode())
180         << " for case number " << i;
181   }
182 }
183
184 TEST(fxcrt, WideStringCOperatorSubscript) {
185     // CFX_WideStringC includes the NUL terminator for non-empty strings.
186     CFX_WideStringC abc(L"abc");
187     EXPECT_EQ(L'a', abc[0]);
188     EXPECT_EQ(L'b', abc[1]);
189     EXPECT_EQ(L'c', abc[2]);
190     EXPECT_EQ(L'\0', abc[3]);
191 }
192
193 TEST(fxcrt, WideStringCOperatorLT) {
194     CFX_WideStringC empty;
195     CFX_WideStringC a(L"a");
196     CFX_WideStringC abc(L"\x0110qq");  // Comes before despite endianness.
197     CFX_WideStringC def(L"\x1001qq");  // Comes after despite endianness.
198
199     EXPECT_FALSE(empty < empty);
200     EXPECT_FALSE(a < a);
201     EXPECT_FALSE(abc < abc);
202     EXPECT_FALSE(def < def);
203
204     EXPECT_TRUE(empty < a);
205     EXPECT_FALSE(a < empty);
206
207     EXPECT_TRUE(empty < abc);
208     EXPECT_FALSE(abc < empty);
209
210     EXPECT_TRUE(empty < def);
211     EXPECT_FALSE(def < empty);
212
213     EXPECT_TRUE(a < abc);
214     EXPECT_FALSE(abc < a);
215
216     EXPECT_TRUE(a < def);
217     EXPECT_FALSE(def < a);
218
219     EXPECT_TRUE(abc < def);
220     EXPECT_FALSE(def < abc);
221 }
222
223 TEST(fxcrt, WideStringCOperatorEQ) {
224     CFX_WideStringC wide_string_c(L"hello");
225     ASSERT_TRUE(wide_string_c == wide_string_c);
226
227     CFX_WideStringC wide_string_c_same1(L"hello");
228     ASSERT_TRUE(wide_string_c == wide_string_c_same1);
229     ASSERT_TRUE(wide_string_c_same1 == wide_string_c);
230
231     CFX_WideStringC wide_string_c_same2(wide_string_c);
232     ASSERT_TRUE(wide_string_c == wide_string_c_same2);
233     ASSERT_TRUE(wide_string_c_same2 == wide_string_c);
234
235     CFX_WideStringC wide_string_c1(L"he");
236     CFX_WideStringC wide_string_c2(L"hellp");
237     CFX_WideStringC wide_string_c3(L"hellod");
238     ASSERT_FALSE(wide_string_c == wide_string_c1);
239     ASSERT_FALSE(wide_string_c == wide_string_c2);
240     ASSERT_FALSE(wide_string_c == wide_string_c3);
241     ASSERT_FALSE(wide_string_c1 == wide_string_c);
242     ASSERT_FALSE(wide_string_c2 == wide_string_c);
243     ASSERT_FALSE(wide_string_c3 == wide_string_c);
244
245     CFX_WideString wide_string_same1(L"hello");
246     ASSERT_TRUE(wide_string_c == wide_string_same1);
247     ASSERT_TRUE(wide_string_same1 == wide_string_c);
248
249     CFX_WideString wide_string1(L"he");
250     CFX_WideString wide_string2(L"hellp");
251     CFX_WideString wide_string3(L"hellod");
252     ASSERT_FALSE(wide_string_c == wide_string1);
253     ASSERT_FALSE(wide_string_c == wide_string2);
254     ASSERT_FALSE(wide_string_c == wide_string3);
255     ASSERT_FALSE(wide_string1 == wide_string_c);
256     ASSERT_FALSE(wide_string2 == wide_string_c);
257     ASSERT_FALSE(wide_string3 == wide_string_c);
258
259 #if 0
260     // TODO(tsepez): ambiguos overload prevents compilation
261     const wchar_t* c_string_same1 = L"hello";
262     ASSERT_TRUE(wide_string_c == c_string_same1);
263     ASSERT_TRUE(c_string_same1 == wide_string_c);
264
265     const wchar_t* c_string1 = L"he";
266     const wchar_t* c_string2 = L"hellp";
267     const wchar_t* c_string3 = L"hellod";
268     ASSERT_FALSE(wide_string_c == c_string1);
269     ASSERT_FALSE(wide_string_c == c_string2);
270     ASSERT_FALSE(wide_string_c == c_string3);
271
272     ASSERT_FALSE(c_string1 == wide_string_c);
273     ASSERT_FALSE(c_string2 == wide_string_c);
274     ASSERT_FALSE(c_string3 == wide_string_c);
275 #endif
276 }
277
278 TEST(fxcrt, WideStringCOperatorNE) {
279     CFX_WideStringC wide_string_c(L"hello");
280     ASSERT_FALSE(wide_string_c != wide_string_c);
281
282     CFX_WideStringC wide_string_c_same1(L"hello");
283     ASSERT_FALSE(wide_string_c != wide_string_c_same1);
284     ASSERT_FALSE(wide_string_c_same1 != wide_string_c);
285
286     CFX_WideStringC wide_string_c_same2(wide_string_c);
287     ASSERT_FALSE(wide_string_c != wide_string_c_same2);
288     ASSERT_FALSE(wide_string_c_same2 != wide_string_c);
289
290     CFX_WideStringC wide_string_c1(L"he");
291     CFX_WideStringC wide_string_c2(L"hellp");
292     CFX_WideStringC wide_string_c3(L"hellod");
293     ASSERT_TRUE(wide_string_c != wide_string_c1);
294     ASSERT_TRUE(wide_string_c != wide_string_c2);
295     ASSERT_TRUE(wide_string_c != wide_string_c3);
296     ASSERT_TRUE(wide_string_c1 != wide_string_c);
297     ASSERT_TRUE(wide_string_c2 != wide_string_c);
298     ASSERT_TRUE(wide_string_c3 != wide_string_c);
299
300     CFX_WideString wide_string_same1(L"hello");
301     ASSERT_FALSE(wide_string_c != wide_string_same1);
302     ASSERT_FALSE(wide_string_same1 != wide_string_c);
303
304     CFX_WideString wide_string1(L"he");
305     CFX_WideString wide_string2(L"hellp");
306     CFX_WideString wide_string3(L"hellod");
307     ASSERT_TRUE(wide_string_c != wide_string1);
308     ASSERT_TRUE(wide_string_c != wide_string2);
309     ASSERT_TRUE(wide_string_c != wide_string3);
310     ASSERT_TRUE(wide_string1 != wide_string_c);
311     ASSERT_TRUE(wide_string2 != wide_string_c);
312     ASSERT_TRUE(wide_string3 != wide_string_c);
313
314 #if 0
315     // See above TODO.
316     const wchar_t* c_string_same1 = L"hello";
317     ASSERT_FALSE(wide_string_c != c_string_same1);
318     ASSERT_FALSE(c_string_same1 != wide_string_c);
319
320     const wchar_t* c_string1 = L"he";
321     const wchar_t* c_string2 = L"hellp";
322     const wchar_t* c_string3 = L"hellod";
323     ASSERT_TRUE(wide_string_c != c_string1);
324     ASSERT_TRUE(wide_string_c != c_string2);
325     ASSERT_TRUE(wide_string_c != c_string3);
326
327     ASSERT_TRUE(c_string1 != wide_string_c);
328     ASSERT_TRUE(c_string2 != wide_string_c);
329     ASSERT_TRUE(c_string3 != wide_string_c);
330 #endif
331 }