1 // Copyright (c) 2015 The Chromium Embedded Framework Authors. All rights
2 // reserved. Use of this source code is governed by a BSD-style license that
3 // can be found in the LICENSE file.
4
5 #include "include/test/cef_translator_test.h"
6 #include "tests/ceftests/test_handler.h"
7 #include "tests/gtest/include/gtest/gtest.h"
8
9 // Test getting/setting primitive types.
TEST(TranslatorTest,Primitive)10 TEST(TranslatorTest, Primitive) {
11 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
12 obj->GetVoid(); // Does nothing, but shouldn't crash.
13 EXPECT_EQ(TEST_BOOL_VAL, obj->GetBool());
14 EXPECT_EQ(TEST_INT_VAL, obj->GetInt());
15 EXPECT_EQ(TEST_DOUBLE_VAL, obj->GetDouble());
16 EXPECT_EQ(TEST_LONG_VAL, obj->GetLong());
17 EXPECT_EQ(TEST_SIZET_VAL, obj->GetSizet());
18 EXPECT_TRUE(obj->SetVoid()); // Does nothing, but shouldn't crash.
19 EXPECT_TRUE(obj->SetBool(TEST_BOOL_VAL));
20 EXPECT_TRUE(obj->SetInt(TEST_INT_VAL));
21 EXPECT_TRUE(obj->SetDouble(TEST_DOUBLE_VAL));
22 EXPECT_TRUE(obj->SetLong(TEST_LONG_VAL));
23 EXPECT_TRUE(obj->SetSizet(TEST_SIZET_VAL));
24
25 // Only one reference to the object should exist.
26 EXPECT_TRUE(obj->HasOneRef());
27 }
28
29 // Test getting/setting primitive list types.
TEST(TranslatorTest,PrimitiveList)30 TEST(TranslatorTest, PrimitiveList) {
31 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
32
33 std::vector<int> list;
34 list.push_back(TEST_INT_VAL);
35 list.push_back(TEST_INT_VAL2);
36 EXPECT_TRUE(obj->SetIntList(list));
37
38 list.clear();
39 EXPECT_TRUE(obj->GetIntListByRef(list));
40 EXPECT_EQ(2U, list.size());
41 EXPECT_EQ(TEST_INT_VAL, list[0]);
42 EXPECT_EQ(TEST_INT_VAL2, list[1]);
43
44 // Only one reference to the object should exist.
45 EXPECT_TRUE(obj->HasOneRef());
46 }
47
48 // Test getting/setting string types.
TEST(TranslatorTest,String)49 TEST(TranslatorTest, String) {
50 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
51 EXPECT_STREQ(TEST_STRING_VAL, obj->GetString().ToString().c_str());
52 EXPECT_TRUE(obj->SetString(TEST_STRING_VAL));
53
54 CefString str;
55 obj->GetStringByRef(str);
56 EXPECT_STREQ(TEST_STRING_VAL, str.ToString().c_str());
57
58 // Only one reference to the object should exist.
59 EXPECT_TRUE(obj->HasOneRef());
60 }
61
62 // Test getting/setting string list types.
TEST(TranslatorTest,StringList)63 TEST(TranslatorTest, StringList) {
64 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
65
66 std::vector<CefString> list;
67 list.push_back(TEST_STRING_VAL);
68 list.push_back(TEST_STRING_VAL2);
69 list.push_back(TEST_STRING_VAL3);
70 EXPECT_TRUE(obj->SetStringList(list));
71
72 list.clear();
73 EXPECT_TRUE(obj->GetStringListByRef(list));
74 EXPECT_EQ(3U, list.size());
75 EXPECT_STREQ(TEST_STRING_VAL, list[0].ToString().c_str());
76 EXPECT_STREQ(TEST_STRING_VAL2, list[1].ToString().c_str());
77 EXPECT_STREQ(TEST_STRING_VAL3, list[2].ToString().c_str());
78
79 // Only one reference to the object should exist.
80 EXPECT_TRUE(obj->HasOneRef());
81 }
82
83 // Test getting/setting string map types.
TEST(TranslatorTest,StringMap)84 TEST(TranslatorTest, StringMap) {
85 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
86
87 CefTranslatorTest::StringMap map;
88 map.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
89 map.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
90 map.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
91 EXPECT_TRUE(obj->SetStringMap(map));
92
93 map.clear();
94 EXPECT_TRUE(obj->GetStringMapByRef(map));
95 EXPECT_EQ(3U, map.size());
96
97 CefTranslatorTest::StringMap::const_iterator it;
98
99 it = map.find(TEST_STRING_KEY);
100 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL);
101 it = map.find(TEST_STRING_KEY2);
102 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL2);
103 it = map.find(TEST_STRING_KEY3);
104 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL3);
105
106 // Only one reference to the object should exist.
107 EXPECT_TRUE(obj->HasOneRef());
108 }
109
110 // Test getting/setting string multimap types.
TEST(TranslatorTest,StringMultimap)111 TEST(TranslatorTest, StringMultimap) {
112 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
113
114 CefTranslatorTest::StringMultimap map;
115 map.insert(std::make_pair(TEST_STRING_KEY, TEST_STRING_VAL));
116 map.insert(std::make_pair(TEST_STRING_KEY2, TEST_STRING_VAL2));
117 map.insert(std::make_pair(TEST_STRING_KEY3, TEST_STRING_VAL3));
118 EXPECT_TRUE(obj->SetStringMultimap(map));
119
120 map.clear();
121 EXPECT_TRUE(obj->GetStringMultimapByRef(map));
122 EXPECT_EQ(3U, map.size());
123
124 CefTranslatorTest::StringMultimap::const_iterator it;
125
126 it = map.find(TEST_STRING_KEY);
127 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL);
128 it = map.find(TEST_STRING_KEY2);
129 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL2);
130 it = map.find(TEST_STRING_KEY3);
131 EXPECT_TRUE(it != map.end() && it->second == TEST_STRING_VAL3);
132
133 // Only one reference to the object should exist.
134 EXPECT_TRUE(obj->HasOneRef());
135 }
136
137 // Test getting/setting struct types.
TEST(TranslatorTest,Struct)138 TEST(TranslatorTest, Struct) {
139 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
140
141 CefPoint point(TEST_X_VAL, TEST_Y_VAL);
142 EXPECT_EQ(point, obj->GetPoint());
143 EXPECT_TRUE(obj->SetPoint(point));
144
145 CefPoint point2;
146 obj->GetPointByRef(point2);
147 EXPECT_EQ(point, point2);
148
149 // Only one reference to the object should exist.
150 EXPECT_TRUE(obj->HasOneRef());
151 }
152
153 // Test getting/setting struct list types.
TEST(TranslatorTest,StructList)154 TEST(TranslatorTest, StructList) {
155 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
156
157 std::vector<CefPoint> list;
158 list.push_back(CefPoint(TEST_X_VAL, TEST_Y_VAL));
159 list.push_back(CefPoint(TEST_X_VAL2, TEST_Y_VAL2));
160 EXPECT_TRUE(obj->SetPointList(list));
161
162 list.clear();
163 EXPECT_TRUE(obj->GetPointListByRef(list));
164 EXPECT_EQ(2U, list.size());
165 EXPECT_EQ(CefPoint(TEST_X_VAL, TEST_Y_VAL), list[0]);
166 EXPECT_EQ(CefPoint(TEST_X_VAL2, TEST_Y_VAL2), list[1]);
167
168 // Only one reference to the object should exist.
169 EXPECT_TRUE(obj->HasOneRef());
170 }
171
172 // Test getting/setting library-side RefPtr types.
TEST(TranslatorTest,RefPtrLibrary)173 TEST(TranslatorTest, RefPtrLibrary) {
174 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
175
176 const int kTestVal = 12;
177 CefRefPtr<CefTranslatorTestRefPtrLibrary> test_obj =
178 CefTranslatorTestRefPtrLibrary::Create(kTestVal);
179 EXPECT_EQ(kTestVal, test_obj->GetValue());
180 int retval = obj->SetRefPtrLibrary(test_obj);
181 EXPECT_EQ(kTestVal, retval);
182 EXPECT_EQ(kTestVal, test_obj->GetValue());
183
184 const int kTestVal2 = 30;
185 CefRefPtr<CefTranslatorTestRefPtrLibrary> test_obj2 =
186 obj->GetRefPtrLibrary(kTestVal2);
187 EXPECT_EQ(kTestVal2, test_obj2->GetValue());
188 int retval2 = obj->SetRefPtrLibrary(test_obj2);
189 EXPECT_EQ(kTestVal2, retval2);
190 EXPECT_EQ(kTestVal2, test_obj2->GetValue());
191
192 // Only one reference to the object should exist.
193 EXPECT_TRUE(obj->HasOneRef());
194 EXPECT_TRUE(test_obj->HasOneRef());
195 EXPECT_TRUE(test_obj2->HasOneRef());
196 }
197
198 // Test getting/setting inherited library-side RefPtr types.
TEST(TranslatorTest,RefPtrLibraryInherit)199 TEST(TranslatorTest, RefPtrLibraryInherit) {
200 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
201
202 const int kTestVal = 12;
203 const int kTestVal2 = 40;
204 CefRefPtr<CefTranslatorTestRefPtrLibraryChild> test_obj =
205 CefTranslatorTestRefPtrLibraryChild::Create(kTestVal, kTestVal2);
206 EXPECT_EQ(kTestVal, test_obj->GetValue());
207 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
208 int retval = obj->SetRefPtrLibrary(test_obj);
209 EXPECT_EQ(kTestVal, retval);
210 EXPECT_EQ(kTestVal, test_obj->GetValue());
211 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
212
213 EXPECT_EQ(kTestVal, obj->SetChildRefPtrLibrary(test_obj));
214 EXPECT_EQ(kTestVal,
215 obj->SetChildRefPtrLibraryAndReturnParent(test_obj)->GetValue());
216
217 const int kTestVal3 = 100;
218 CefRefPtr<CefTranslatorTestRefPtrLibraryChildChild> test_obj2 =
219 CefTranslatorTestRefPtrLibraryChildChild::Create(kTestVal, kTestVal2,
220 kTestVal3);
221 EXPECT_EQ(kTestVal, test_obj2->GetValue());
222 EXPECT_EQ(kTestVal2, test_obj2->GetOtherValue());
223 EXPECT_EQ(kTestVal3, test_obj2->GetOtherOtherValue());
224 int retval2 = obj->SetRefPtrLibrary(test_obj2);
225 EXPECT_EQ(kTestVal, retval2);
226 EXPECT_EQ(kTestVal, test_obj2->GetValue());
227 EXPECT_EQ(kTestVal2, test_obj2->GetOtherValue());
228 EXPECT_EQ(kTestVal3, test_obj2->GetOtherOtherValue());
229
230 EXPECT_EQ(kTestVal, obj->SetChildRefPtrLibrary(test_obj2));
231 EXPECT_EQ(kTestVal,
232 obj->SetChildRefPtrLibraryAndReturnParent(test_obj2)->GetValue());
233
234 // Only one reference to the object should exist.
235 EXPECT_TRUE(obj->HasOneRef());
236 EXPECT_TRUE(test_obj->HasOneRef());
237 EXPECT_TRUE(test_obj2->HasOneRef());
238 }
239
240 // Test getting/setting library-side RefPtr list types.
TEST(TranslatorTest,RefPtrLibraryList)241 TEST(TranslatorTest, RefPtrLibraryList) {
242 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
243
244 const int kVal1 = 34;
245 const int kVal2 = 10;
246
247 CefRefPtr<CefTranslatorTestRefPtrLibrary> val1 =
248 CefTranslatorTestRefPtrLibrary::Create(kVal1);
249 CefRefPtr<CefTranslatorTestRefPtrLibrary> val2 =
250 CefTranslatorTestRefPtrLibraryChild::Create(kVal2, 0);
251
252 std::vector<CefRefPtr<CefTranslatorTestRefPtrLibrary>> list;
253 list.push_back(val1);
254 list.push_back(val2);
255 EXPECT_TRUE(obj->SetRefPtrLibraryList(list, kVal1, kVal2));
256
257 list.clear();
258 EXPECT_TRUE(obj->GetRefPtrLibraryListByRef(list, kVal1, kVal2));
259 EXPECT_EQ(2U, list.size());
260 EXPECT_EQ(kVal1, list[0]->GetValue());
261 EXPECT_EQ(kVal2, list[1]->GetValue());
262
263 list.clear();
264
265 // Only one reference to the object should exist.
266 EXPECT_TRUE(obj->HasOneRef());
267 EXPECT_TRUE(val1->HasOneRef());
268 EXPECT_TRUE(val2->HasOneRef());
269 }
270
271 namespace {
272
273 class TranslatorTestRefPtrClient : public CefTranslatorTestRefPtrClient {
274 public:
TranslatorTestRefPtrClient(const int val)275 explicit TranslatorTestRefPtrClient(const int val) : val_(val) {}
276
GetValue()277 virtual int GetValue() override { return val_; }
278
279 private:
280 const int val_;
281
282 IMPLEMENT_REFCOUNTING(TranslatorTestRefPtrClient);
283 DISALLOW_COPY_AND_ASSIGN(TranslatorTestRefPtrClient);
284 };
285
286 class TranslatorTestRefPtrClientChild
287 : public CefTranslatorTestRefPtrClientChild {
288 public:
TranslatorTestRefPtrClientChild(const int val,const int other_val)289 TranslatorTestRefPtrClientChild(const int val, const int other_val)
290 : val_(val), other_val_(other_val) {}
291
GetValue()292 virtual int GetValue() override { return val_; }
293
GetOtherValue()294 virtual int GetOtherValue() override { return other_val_; }
295
296 private:
297 const int val_;
298 const int other_val_;
299
300 IMPLEMENT_REFCOUNTING(TranslatorTestRefPtrClientChild);
301 DISALLOW_COPY_AND_ASSIGN(TranslatorTestRefPtrClientChild);
302 };
303
304 } // namespace
305
306 // Test getting/setting client-side RefPtr types.
TEST(TranslatorTest,RefPtrClient)307 TEST(TranslatorTest, RefPtrClient) {
308 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
309
310 const int kTestVal = 12;
311
312 CefRefPtr<TranslatorTestRefPtrClient> test_obj =
313 new TranslatorTestRefPtrClient(kTestVal);
314 EXPECT_EQ(kTestVal, test_obj->GetValue());
315 EXPECT_EQ(kTestVal, obj->SetRefPtrClient(test_obj.get()));
316 CefRefPtr<CefTranslatorTestRefPtrClient> handler =
317 obj->SetRefPtrClientAndReturn(test_obj.get());
318 EXPECT_EQ(test_obj.get(), handler.get());
319 EXPECT_EQ(kTestVal, handler->GetValue());
320 handler = nullptr;
321
322 // Only one reference to the object should exist.
323 EXPECT_TRUE(obj->HasOneRef());
324 EXPECT_TRUE(test_obj->HasOneRef());
325 }
326
327 // Test getting/setting inherited client-side RefPtr types.
TEST(TranslatorTest,RefPtrClientInherit)328 TEST(TranslatorTest, RefPtrClientInherit) {
329 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
330
331 const int kTestVal = 12;
332 const int kTestVal2 = 86;
333
334 CefRefPtr<TranslatorTestRefPtrClientChild> test_obj =
335 new TranslatorTestRefPtrClientChild(kTestVal, kTestVal2);
336 EXPECT_EQ(kTestVal, test_obj->GetValue());
337 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
338 int retval = obj->SetRefPtrClient(test_obj);
339 EXPECT_EQ(kTestVal, retval);
340 EXPECT_EQ(kTestVal, test_obj->GetValue());
341 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
342
343 EXPECT_EQ(kTestVal, obj->SetChildRefPtrClient(test_obj));
344 CefRefPtr<CefTranslatorTestRefPtrClient> handler =
345 obj->SetChildRefPtrClientAndReturnParent(test_obj);
346 EXPECT_EQ(kTestVal, handler->GetValue());
347 EXPECT_EQ(test_obj.get(), handler.get());
348 handler = nullptr;
349
350 // Only one reference to the object should exist.
351 EXPECT_TRUE(obj->HasOneRef());
352 EXPECT_TRUE(test_obj->HasOneRef());
353 }
354
355 // Test getting/setting client-side RefPtr list types.
TEST(TranslatorTest,RefPtrClientList)356 TEST(TranslatorTest, RefPtrClientList) {
357 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
358
359 const int kVal1 = 34;
360 const int kVal2 = 10;
361
362 CefRefPtr<CefTranslatorTestRefPtrClient> val1 =
363 new TranslatorTestRefPtrClient(kVal1);
364 CefRefPtr<CefTranslatorTestRefPtrClient> val2 =
365 new TranslatorTestRefPtrClientChild(kVal2, 0);
366
367 std::vector<CefRefPtr<CefTranslatorTestRefPtrClient>> list;
368 list.push_back(val1);
369 list.push_back(val2);
370 EXPECT_TRUE(obj->SetRefPtrClientList(list, kVal1, kVal2));
371
372 list.clear();
373 EXPECT_TRUE(obj->GetRefPtrClientListByRef(list, val1, val2));
374 EXPECT_EQ(2U, list.size());
375 EXPECT_EQ(kVal1, list[0]->GetValue());
376 EXPECT_EQ(val1.get(), list[0].get());
377 EXPECT_EQ(kVal2, list[1]->GetValue());
378 EXPECT_EQ(val2.get(), list[1].get());
379
380 list.clear();
381
382 // Only one reference to the object should exist.
383 EXPECT_TRUE(obj->HasOneRef());
384 EXPECT_TRUE(val1->HasOneRef());
385 EXPECT_TRUE(val2->HasOneRef());
386 }
387
388 // Test getting/setting library-side OwnPtr types.
TEST(TranslatorTest,OwnPtrLibrary)389 TEST(TranslatorTest, OwnPtrLibrary) {
390 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
391
392 const int kTestVal = 12;
393 CefOwnPtr<CefTranslatorTestScopedLibrary> test_obj =
394 CefTranslatorTestScopedLibrary::Create(kTestVal);
395 EXPECT_TRUE(test_obj.get());
396 EXPECT_EQ(kTestVal, test_obj->GetValue());
397 int retval = obj->SetOwnPtrLibrary(std::move(test_obj));
398 EXPECT_EQ(kTestVal, retval);
399 EXPECT_FALSE(test_obj.get());
400
401 const int kTestVal2 = 30;
402 CefOwnPtr<CefTranslatorTestScopedLibrary> test_obj2 =
403 obj->GetOwnPtrLibrary(kTestVal2);
404 EXPECT_TRUE(test_obj2.get());
405 EXPECT_EQ(kTestVal2, test_obj2->GetValue());
406 int retval2 = obj->SetOwnPtrLibrary(std::move(test_obj2));
407 EXPECT_EQ(kTestVal2, retval2);
408 EXPECT_FALSE(test_obj2.get());
409
410 // Only one reference to the object should exist.
411 EXPECT_TRUE(obj->HasOneRef());
412 }
413
414 // Test getting/setting inherited library-side OwnPtr types.
TEST(TranslatorTest,OwnPtrLibraryInherit)415 TEST(TranslatorTest, OwnPtrLibraryInherit) {
416 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
417
418 const int kTestVal = 12;
419 const int kTestVal2 = 40;
420 CefOwnPtr<CefTranslatorTestScopedLibraryChild> test_obj =
421 CefTranslatorTestScopedLibraryChild::Create(kTestVal, kTestVal2);
422 EXPECT_TRUE(test_obj.get());
423 EXPECT_EQ(kTestVal, test_obj->GetValue());
424 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
425 int retval = obj->SetOwnPtrLibrary(std::move(test_obj));
426 EXPECT_EQ(kTestVal, retval);
427 EXPECT_FALSE(test_obj.get());
428
429 test_obj = CefTranslatorTestScopedLibraryChild::Create(kTestVal, kTestVal2);
430 EXPECT_TRUE(test_obj.get());
431 EXPECT_EQ(kTestVal, obj->SetChildOwnPtrLibrary(std::move(test_obj)));
432 EXPECT_FALSE(test_obj.get());
433
434 test_obj = CefTranslatorTestScopedLibraryChild::Create(kTestVal, kTestVal2);
435 EXPECT_TRUE(test_obj.get());
436 CefOwnPtr<CefTranslatorTestScopedLibrary> test_obj_parent =
437 obj->SetChildOwnPtrLibraryAndReturnParent(std::move(test_obj));
438 EXPECT_FALSE(test_obj.get());
439 EXPECT_TRUE(test_obj_parent.get());
440 EXPECT_EQ(kTestVal, test_obj_parent->GetValue());
441 test_obj_parent.reset(nullptr);
442
443 const int kTestVal3 = 100;
444 CefOwnPtr<CefTranslatorTestScopedLibraryChildChild> test_obj2 =
445 CefTranslatorTestScopedLibraryChildChild::Create(kTestVal, kTestVal2,
446 kTestVal3);
447 EXPECT_EQ(kTestVal, test_obj2->GetValue());
448 EXPECT_EQ(kTestVal2, test_obj2->GetOtherValue());
449 EXPECT_EQ(kTestVal3, test_obj2->GetOtherOtherValue());
450 int retval2 = obj->SetOwnPtrLibrary(std::move(test_obj2));
451 EXPECT_EQ(kTestVal, retval2);
452 EXPECT_FALSE(test_obj2.get());
453
454 test_obj2 = CefTranslatorTestScopedLibraryChildChild::Create(
455 kTestVal, kTestVal2, kTestVal3);
456 EXPECT_EQ(kTestVal, obj->SetChildOwnPtrLibrary(std::move(test_obj2)));
457 EXPECT_FALSE(test_obj2.get());
458
459 test_obj2 = CefTranslatorTestScopedLibraryChildChild::Create(
460 kTestVal, kTestVal2, kTestVal3);
461 test_obj_parent =
462 obj->SetChildOwnPtrLibraryAndReturnParent(std::move(test_obj2));
463 EXPECT_FALSE(test_obj2.get());
464 EXPECT_TRUE(test_obj_parent.get());
465 EXPECT_EQ(kTestVal, test_obj_parent->GetValue());
466 test_obj_parent.reset(nullptr);
467
468 // Only one reference to the object should exist.
469 EXPECT_TRUE(obj->HasOneRef());
470 }
471
472 namespace {
473
474 class TranslatorTestScopedClient : public CefTranslatorTestScopedClient {
475 public:
TranslatorTestScopedClient(const int val,TrackCallback * got_delete)476 TranslatorTestScopedClient(const int val, TrackCallback* got_delete)
477 : val_(val), got_delete_(got_delete) {}
~TranslatorTestScopedClient()478 ~TranslatorTestScopedClient() override { got_delete_->yes(); }
479
GetValue()480 virtual int GetValue() override { return val_; }
481
482 private:
483 const int val_;
484 TrackCallback* got_delete_;
485
486 DISALLOW_COPY_AND_ASSIGN(TranslatorTestScopedClient);
487 };
488
489 class TranslatorTestScopedClientChild
490 : public CefTranslatorTestScopedClientChild {
491 public:
TranslatorTestScopedClientChild(const int val,const int other_val,TrackCallback * got_delete)492 TranslatorTestScopedClientChild(const int val,
493 const int other_val,
494 TrackCallback* got_delete)
495 : val_(val), other_val_(other_val), got_delete_(got_delete) {}
~TranslatorTestScopedClientChild()496 ~TranslatorTestScopedClientChild() override { got_delete_->yes(); }
497
GetValue()498 virtual int GetValue() override { return val_; }
499
GetOtherValue()500 virtual int GetOtherValue() override { return other_val_; }
501
502 private:
503 const int val_;
504 const int other_val_;
505 TrackCallback* got_delete_;
506
507 DISALLOW_COPY_AND_ASSIGN(TranslatorTestScopedClientChild);
508 };
509
510 } // namespace
511
512 // Test getting/setting client-side OwnPtr types.
TEST(TranslatorTest,OwnPtrClient)513 TEST(TranslatorTest, OwnPtrClient) {
514 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
515
516 const int kTestVal = 12;
517 TrackCallback got_delete;
518
519 CefOwnPtr<CefTranslatorTestScopedClient> test_obj(
520 new TranslatorTestScopedClient(kTestVal, &got_delete));
521 EXPECT_EQ(kTestVal, test_obj->GetValue());
522 EXPECT_EQ(kTestVal, obj->SetOwnPtrClient(std::move(test_obj)));
523 EXPECT_FALSE(test_obj.get());
524 EXPECT_TRUE(got_delete);
525
526 got_delete.reset();
527 test_obj.reset(new TranslatorTestScopedClient(kTestVal, &got_delete));
528 CefOwnPtr<CefTranslatorTestScopedClient> handler =
529 obj->SetOwnPtrClientAndReturn(std::move(test_obj));
530 EXPECT_FALSE(test_obj.get());
531 EXPECT_TRUE(handler.get());
532 EXPECT_FALSE(got_delete);
533 EXPECT_EQ(kTestVal, handler->GetValue());
534 handler.reset(nullptr);
535 EXPECT_TRUE(got_delete);
536
537 // Only one reference to the object should exist.
538 EXPECT_TRUE(obj->HasOneRef());
539 }
540
541 // Test getting/setting inherited client-side OwnPtr types.
TEST(TranslatorTest,OwnPtrClientInherit)542 TEST(TranslatorTest, OwnPtrClientInherit) {
543 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
544
545 const int kTestVal = 12;
546 const int kTestVal2 = 86;
547 TrackCallback got_delete;
548
549 CefOwnPtr<CefTranslatorTestScopedClientChild> test_obj(
550 new TranslatorTestScopedClientChild(kTestVal, kTestVal2, &got_delete));
551 EXPECT_EQ(kTestVal, test_obj->GetValue());
552 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
553 EXPECT_EQ(kTestVal, obj->SetOwnPtrClient(std::move(test_obj)));
554 EXPECT_FALSE(test_obj.get());
555 EXPECT_TRUE(got_delete);
556
557 got_delete.reset();
558 test_obj.reset(
559 new TranslatorTestScopedClientChild(kTestVal, kTestVal2, &got_delete));
560 EXPECT_EQ(kTestVal, obj->SetChildOwnPtrClient(std::move(test_obj)));
561 EXPECT_FALSE(test_obj.get());
562 EXPECT_TRUE(got_delete);
563
564 got_delete.reset();
565 test_obj.reset(
566 new TranslatorTestScopedClientChild(kTestVal, kTestVal2, &got_delete));
567 CefOwnPtr<CefTranslatorTestScopedClient> handler(
568 obj->SetChildOwnPtrClientAndReturnParent(std::move(test_obj)));
569 EXPECT_EQ(kTestVal, handler->GetValue());
570 EXPECT_FALSE(test_obj.get());
571 EXPECT_FALSE(got_delete);
572 handler.reset(nullptr);
573 EXPECT_TRUE(got_delete);
574
575 // Only one reference to the object should exist.
576 EXPECT_TRUE(obj->HasOneRef());
577 }
578
579 // Test getting/setting library-side RawPtr types.
TEST(TranslatorTest,RawPtrLibrary)580 TEST(TranslatorTest, RawPtrLibrary) {
581 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
582
583 const int kTestVal = 12;
584 CefOwnPtr<CefTranslatorTestScopedLibrary> test_obj(
585 CefTranslatorTestScopedLibrary::Create(kTestVal));
586 EXPECT_EQ(kTestVal, test_obj->GetValue());
587 int retval = obj->SetRawPtrLibrary(test_obj.get());
588 EXPECT_EQ(kTestVal, retval);
589 EXPECT_EQ(kTestVal, test_obj->GetValue());
590
591 const int kTestVal2 = 30;
592 CefOwnPtr<CefTranslatorTestScopedLibrary> test_obj2(
593 obj->GetOwnPtrLibrary(kTestVal2));
594 EXPECT_EQ(kTestVal2, test_obj2->GetValue());
595 int retval2 = obj->SetRawPtrLibrary(test_obj2.get());
596 EXPECT_EQ(kTestVal2, retval2);
597 EXPECT_EQ(kTestVal2, test_obj2->GetValue());
598
599 // Only one reference to the object should exist.
600 EXPECT_TRUE(obj->HasOneRef());
601 }
602
603 // Test getting/setting inherited library-side RawPtr types.
TEST(TranslatorTest,RawPtrLibraryInherit)604 TEST(TranslatorTest, RawPtrLibraryInherit) {
605 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
606
607 const int kTestVal = 12;
608 const int kTestVal2 = 40;
609 CefOwnPtr<CefTranslatorTestScopedLibraryChild> test_obj(
610 CefTranslatorTestScopedLibraryChild::Create(kTestVal, kTestVal2));
611 EXPECT_EQ(kTestVal, test_obj->GetValue());
612 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
613 int retval = obj->SetRawPtrLibrary(test_obj.get());
614 EXPECT_EQ(kTestVal, retval);
615 EXPECT_EQ(kTestVal, test_obj->GetValue());
616 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
617
618 EXPECT_EQ(kTestVal, obj->SetChildRawPtrLibrary(test_obj.get()));
619
620 const int kTestVal3 = 100;
621 CefOwnPtr<CefTranslatorTestScopedLibraryChildChild> test_obj2(
622 CefTranslatorTestScopedLibraryChildChild::Create(kTestVal, kTestVal2,
623 kTestVal3));
624 EXPECT_EQ(kTestVal, test_obj2->GetValue());
625 EXPECT_EQ(kTestVal2, test_obj2->GetOtherValue());
626 EXPECT_EQ(kTestVal3, test_obj2->GetOtherOtherValue());
627 int retval2 = obj->SetRawPtrLibrary(test_obj2.get());
628 EXPECT_EQ(kTestVal, retval2);
629 EXPECT_EQ(kTestVal, test_obj2->GetValue());
630 EXPECT_EQ(kTestVal2, test_obj2->GetOtherValue());
631 EXPECT_EQ(kTestVal3, test_obj2->GetOtherOtherValue());
632
633 EXPECT_EQ(kTestVal, obj->SetChildRawPtrLibrary(test_obj2.get()));
634
635 // Only one reference to the object should exist.
636 EXPECT_TRUE(obj->HasOneRef());
637 }
638
639 // Test getting/setting library-side RawPtr list types.
TEST(TranslatorTest,RawPtrLibraryList)640 TEST(TranslatorTest, RawPtrLibraryList) {
641 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
642
643 const int kVal1 = 34;
644 const int kVal2 = 10;
645
646 CefOwnPtr<CefTranslatorTestScopedLibrary> val1(
647 CefTranslatorTestScopedLibrary::Create(kVal1));
648 CefOwnPtr<CefTranslatorTestScopedLibraryChild> val2(
649 CefTranslatorTestScopedLibraryChild::Create(kVal2, 0));
650
651 std::vector<CefRawPtr<CefTranslatorTestScopedLibrary>> list;
652 list.push_back(val1.get());
653 list.push_back(val2.get());
654 EXPECT_TRUE(obj->SetRawPtrLibraryList(list, kVal1, kVal2));
655 list.clear();
656
657 // Only one reference to the object should exist.
658 EXPECT_TRUE(obj->HasOneRef());
659 }
660
661 // Test getting/setting client-side RawPtr types.
TEST(TranslatorTest,RawPtrClient)662 TEST(TranslatorTest, RawPtrClient) {
663 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
664
665 const int kTestVal = 12;
666 TrackCallback got_delete;
667
668 CefOwnPtr<TranslatorTestScopedClient> test_obj(
669 new TranslatorTestScopedClient(kTestVal, &got_delete));
670 EXPECT_EQ(kTestVal, test_obj->GetValue());
671 EXPECT_EQ(kTestVal, obj->SetRawPtrClient(test_obj.get()));
672 EXPECT_FALSE(got_delete);
673 test_obj.reset(nullptr);
674 EXPECT_TRUE(got_delete);
675
676 // Only one reference to the object should exist.
677 EXPECT_TRUE(obj->HasOneRef());
678 }
679
680 // Test getting/setting inherited client-side RawPtr types.
TEST(TranslatorTest,RawPtrClientInherit)681 TEST(TranslatorTest, RawPtrClientInherit) {
682 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
683
684 const int kTestVal = 12;
685 const int kTestVal2 = 86;
686 TrackCallback got_delete;
687
688 CefOwnPtr<TranslatorTestScopedClientChild> test_obj(
689 new TranslatorTestScopedClientChild(kTestVal, kTestVal2, &got_delete));
690 EXPECT_EQ(kTestVal, test_obj->GetValue());
691 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
692 int retval = obj->SetRawPtrClient(test_obj.get());
693 EXPECT_EQ(kTestVal, retval);
694 EXPECT_EQ(kTestVal, test_obj->GetValue());
695 EXPECT_EQ(kTestVal2, test_obj->GetOtherValue());
696 EXPECT_FALSE(got_delete);
697
698 EXPECT_EQ(kTestVal, obj->SetChildRawPtrClient(test_obj.get()));
699 EXPECT_FALSE(got_delete);
700 test_obj.reset(nullptr);
701 EXPECT_TRUE(got_delete);
702
703 // Only one reference to the object should exist.
704 EXPECT_TRUE(obj->HasOneRef());
705 }
706
707 // Test getting/setting client-side RawPtr list types.
TEST(TranslatorTest,RawPtrClientList)708 TEST(TranslatorTest, RawPtrClientList) {
709 CefRefPtr<CefTranslatorTest> obj = CefTranslatorTest::Create();
710
711 const int kVal1 = 34;
712 const int kVal2 = 10;
713 TrackCallback got_delete1, got_delete2;
714
715 CefOwnPtr<CefTranslatorTestScopedClient> val1(
716 new TranslatorTestScopedClient(kVal1, &got_delete1));
717 CefOwnPtr<CefTranslatorTestScopedClient> val2(
718 new TranslatorTestScopedClientChild(kVal2, 0, &got_delete2));
719
720 std::vector<CefRawPtr<CefTranslatorTestScopedClient>> list;
721 list.push_back(val1.get());
722 list.push_back(val2.get());
723 EXPECT_TRUE(obj->SetRawPtrClientList(list, kVal1, kVal2));
724 list.clear();
725
726 EXPECT_FALSE(got_delete1);
727 val1.reset(nullptr);
728 EXPECT_TRUE(got_delete1);
729
730 EXPECT_FALSE(got_delete2);
731 val2.reset(nullptr);
732 EXPECT_TRUE(got_delete2);
733
734 // Only one reference to the object should exist.
735 EXPECT_TRUE(obj->HasOneRef());
736 }
737