Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(488)

Issues Search
    My Issues | Starred     Open | Closed | All

Side by Side Diff: chrome/test/live_sync/two_client_bookmarks_sync_test.cc

Issue 7828055: Move sync test code out of chrome/test (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src/
Patch Set: '' Created 9 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
« no previous file with comments | « chrome/test/live_sync/two_client_autofill_sync_test.cc ('k') | chrome/test/live_sync/two_client_extensions_sync_test.cc » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(Empty)
1 // Copyright (c) 2011 The Chromium 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 "base/rand_util.h"
6 #include "chrome/browser/profiles/profile.h"
7 #include "chrome/browser/sync/profile_sync_service_harness.h"
8 #include "chrome/test/live_sync/bookmarks_helper.h"
9 #include "chrome/test/live_sync/live_sync_test.h"
10
11 using bookmarks_helper::AddFolder;
12 using bookmarks_helper::AddURL;
13 using bookmarks_helper::AllModelsMatch;
14 using bookmarks_helper::AllModelsMatchVerifier;
15 using bookmarks_helper::ContainsDuplicateBookmarks;
16 using bookmarks_helper::CountBookmarksWithTitlesMatching;
17 using bookmarks_helper::CreateFavicon;
18 using bookmarks_helper::GetBookmarkBarNode;
19 using bookmarks_helper::GetOtherNode;
20 using bookmarks_helper::GetUniqueNodeByURL;
21 using bookmarks_helper::IndexedFolderName;
22 using bookmarks_helper::IndexedSubfolderName;
23 using bookmarks_helper::IndexedSubsubfolderName;
24 using bookmarks_helper::IndexedURL;
25 using bookmarks_helper::IndexedURLTitle;
26 using bookmarks_helper::Move;
27 using bookmarks_helper::Remove;
28 using bookmarks_helper::ReverseChildOrder;
29 using bookmarks_helper::SetFavicon;
30 using bookmarks_helper::SetTitle;
31 using bookmarks_helper::SetURL;
32 using bookmarks_helper::SortChildren;
33
34 const std::string kGenericURL = "http://www.host.ext:1234/path/filename";
35 const std::wstring kGenericURLTitle = L"URL Title";
36 const std::wstring kGenericFolderName = L"Folder Name";
37 const std::wstring kGenericSubfolderName = L"Subfolder Name";
38 const std::wstring kGenericSubsubfolderName = L"Subsubfolder Name";
39
40 class TwoClientBookmarksSyncTest : public LiveSyncTest {
41 public:
42 TwoClientBookmarksSyncTest() : LiveSyncTest(TWO_CLIENT) {}
43 virtual ~TwoClientBookmarksSyncTest() {}
44
45 private:
46 DISALLOW_COPY_AND_ASSIGN(TwoClientBookmarksSyncTest);
47 };
48
49 const std::vector<unsigned char> GenericFavicon() {
50 return CreateFavicon(254);
51 }
52
53 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, Sanity) {
54 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
55 ASSERT_TRUE(AllModelsMatchVerifier());
56
57 GURL google_url("http://www.google.com");
58 ASSERT_TRUE(AddURL(0, L"Google", google_url) != NULL);
59 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
60 ASSERT_TRUE(AddURL(1, L"Yahoo", GURL("http://www.yahoo.com")) != NULL);
61 ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
62 ASSERT_TRUE(AllModelsMatchVerifier());
63
64 const BookmarkNode* new_folder = AddFolder(0, 2, L"New Folder");
65 Move(0, GetUniqueNodeByURL(0, google_url), new_folder, 0);
66 SetTitle(0, GetBookmarkBarNode(0)->GetChild(0), L"Yahoo!!");
67 ASSERT_TRUE(AddURL(0, GetBookmarkBarNode(0), 1, L"CNN",
68 GURL("http://www.cnn.com")) != NULL);
69 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
70 ASSERT_TRUE(AllModelsMatchVerifier());
71
72 ASSERT_TRUE(AddURL(1, L"Facebook", GURL("http://www.facebook.com")) != NULL);
73 ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
74 ASSERT_TRUE(AllModelsMatchVerifier());
75
76 SortChildren(1, GetBookmarkBarNode(1));
77 ASSERT_TRUE(GetClient(1)->AwaitMutualSyncCycleCompletion(GetClient(0)));
78 ASSERT_TRUE(AllModelsMatchVerifier());
79
80 DisableVerifier();
81 SetTitle(0, GetUniqueNodeByURL(0, google_url), L"Google++");
82 SetTitle(1, GetUniqueNodeByURL(1, google_url), L"Google--");
83 ASSERT_TRUE(AwaitQuiescence());
84 ASSERT_TRUE(AllModelsMatch());
85 }
86
87 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SimultaneousURLChanges) {
88 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
89 ASSERT_TRUE(AllModelsMatchVerifier());
90
91 GURL initial_url("http://www.google.com");
92 GURL second_url("http://www.google.com/abc");
93 GURL third_url("http://www.google.com/def");
94 std::wstring title = L"Google";
95
96 ASSERT_TRUE(AddURL(0, title, initial_url) != NULL);
97 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
98
99 DisableVerifier();
100 ASSERT_TRUE(SetURL(
101 0, GetUniqueNodeByURL(0, initial_url), second_url) != NULL);
102 ASSERT_TRUE(SetURL(
103 1, GetUniqueNodeByURL(1, initial_url), third_url) != NULL);
104 ASSERT_TRUE(AwaitQuiescence());
105 ASSERT_TRUE(AllModelsMatch());
106
107 SetTitle(0, GetBookmarkBarNode(0)->GetChild(0), L"Google1");
108 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
109 ASSERT_TRUE(AllModelsMatch());
110 }
111
112 // Test Scribe ID - 370558.
113 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_AddFirstFolder) {
114 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
115 ASSERT_TRUE(AllModelsMatchVerifier());
116
117 ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
118 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
119 ASSERT_TRUE(AllModelsMatchVerifier());
120 }
121
122 // Test Scribe ID - 370559.
123 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
124 SC_AddFirstBMWithoutFavicon) {
125 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
126 ASSERT_TRUE(AllModelsMatchVerifier());
127
128 ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
129 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
130 ASSERT_TRUE(AllModelsMatchVerifier());
131 }
132
133 // Test Scribe ID - 370489.
134 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
135 SC_AddFirstBMWithFavicon) {
136 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
137 ASSERT_TRUE(AllModelsMatchVerifier());
138
139 const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, GURL(kGenericURL));
140 ASSERT_TRUE(bookmark != NULL);
141 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
142 SetFavicon(0, bookmark, GenericFavicon());
143 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
144 ASSERT_TRUE(AllModelsMatchVerifier());
145 }
146
147 // Test Scribe ID - 370560.
148 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_AddNonHTTPBMs) {
149 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
150 ASSERT_TRUE(AllModelsMatchVerifier());
151
152 ASSERT_TRUE(AddURL(
153 0, L"FTP URL", GURL("ftp://user:password@host:1234/path")) != NULL);
154 ASSERT_TRUE(AddURL(0, L"File URL", GURL("file://host/path")) != NULL);
155 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
156 ASSERT_TRUE(AllModelsMatchVerifier());
157 }
158
159 // Test Scribe ID - 370561.
160 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
161 SC_AddFirstBMUnderFolder) {
162 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
163 ASSERT_TRUE(AllModelsMatchVerifier());
164
165 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
166 ASSERT_TRUE(folder != NULL);
167 ASSERT_TRUE(AddURL(
168 0, folder, 0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
169 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
170 ASSERT_TRUE(AllModelsMatchVerifier());
171 }
172
173 // Test Scribe ID - 370562.
174 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
175 SC_AddSeveralBMsUnderBMBarAndOtherBM) {
176 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
177 ASSERT_TRUE(AllModelsMatchVerifier());
178
179 for (int i = 0; i < 20; ++i) {
180 std::wstring title = IndexedURLTitle(i);
181 GURL url = GURL(IndexedURL(i));
182 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
183 ASSERT_TRUE(AddURL(
184 0, GetOtherNode(0), i, title, url) != NULL);
185 }
186 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
187 ASSERT_TRUE(AllModelsMatchVerifier());
188 }
189
190 // Test Scribe ID - 370563.
191 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
192 SC_AddSeveralBMsAndFolders) {
193 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
194 ASSERT_TRUE(AllModelsMatchVerifier());
195
196 for (int i = 0; i < 15; ++i) {
197 if (base::RandDouble() > 0.6) {
198 std::wstring title = IndexedURLTitle(i);
199 GURL url = GURL(IndexedURL(i));
200 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
201 } else {
202 std::wstring title = IndexedFolderName(i);
203 const BookmarkNode* folder = AddFolder(0, i, title);
204 ASSERT_TRUE(folder != NULL);
205 if (base::RandDouble() > 0.4) {
206 for (int i = 0; i < 20; ++i) {
207 std::wstring title = IndexedURLTitle(i);
208 GURL url = GURL(IndexedURL(i));
209 ASSERT_TRUE(
210 AddURL(0, folder, i, title, url) != NULL);
211 }
212 }
213 }
214 }
215 for (int i = 0; i < 10; i++) {
216 std::wstring title = IndexedURLTitle(i);
217 GURL url = GURL(IndexedURL(i));
218 ASSERT_TRUE(AddURL(0, GetOtherNode(0), i, title, url) != NULL);
219 }
220 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
221 ASSERT_TRUE(AllModelsMatchVerifier());
222 }
223
224 // Test Scribe ID - 370641.
225 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
226 SC_DuplicateBMWithDifferentURLSameName) {
227 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
228 ASSERT_TRUE(AllModelsMatchVerifier());
229
230 GURL url0 = GURL(IndexedURL(0));
231 GURL url1 = GURL(IndexedURL(1));
232 ASSERT_TRUE(AddURL(0, kGenericURLTitle, url0) != NULL);
233 ASSERT_TRUE(AddURL(0, kGenericURLTitle, url1) != NULL);
234 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
235 ASSERT_TRUE(AllModelsMatchVerifier());
236 }
237
238 // Test Scribe ID - 370639 - Add bookmarks with different name and same URL.
239 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
240 SC_DuplicateBookmarksWithSameURL) {
241 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
242 ASSERT_TRUE(AllModelsMatchVerifier());
243
244 std::wstring title0 = IndexedURLTitle(0);
245 std::wstring title1 = IndexedURLTitle(1);
246 ASSERT_TRUE(AddURL(0, title0, GURL(kGenericURL)) != NULL);
247 ASSERT_TRUE(AddURL(0, title1, GURL(kGenericURL)) != NULL);
248 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
249 ASSERT_TRUE(AllModelsMatchVerifier());
250 }
251
252 // Test Scribe ID - 371817.
253 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMName) {
254 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
255 ASSERT_TRUE(AllModelsMatchVerifier());
256
257 std::wstring title = IndexedURLTitle(1);
258 const BookmarkNode* bookmark = AddURL(0, title, GURL(kGenericURL));
259 ASSERT_TRUE(bookmark != NULL);
260 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
261 ASSERT_TRUE(AllModelsMatchVerifier());
262
263 std::wstring new_title = IndexedURLTitle(2);
264 SetTitle(0, bookmark, new_title);
265 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
266 ASSERT_TRUE(AllModelsMatchVerifier());
267 }
268
269 // Test Scribe ID - 371822.
270 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMURL) {
271 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
272 ASSERT_TRUE(AllModelsMatchVerifier());
273
274 GURL url = GURL(IndexedURL(1));
275 const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, url);
276 ASSERT_TRUE(bookmark != NULL);
277 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
278 ASSERT_TRUE(AllModelsMatchVerifier());
279
280 GURL new_url = GURL(IndexedURL(2));
281 ASSERT_TRUE(SetURL(0, bookmark, new_url) != NULL);
282 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
283 ASSERT_TRUE(AllModelsMatchVerifier());
284 }
285
286
287 // Test Scribe ID - 371818 - Renaming the same bookmark name twice.
288 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
289 SC_TwiceRenamingBookmarkName) {
290 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
291 ASSERT_TRUE(AllModelsMatchVerifier());
292
293 std::wstring title = IndexedURLTitle(1);
294 const BookmarkNode* bookmark = AddURL(0, title, GURL(kGenericURL));
295 ASSERT_TRUE(bookmark != NULL);
296 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
297 ASSERT_TRUE(AllModelsMatchVerifier());
298
299 std::wstring new_title = IndexedURLTitle(2);
300 SetTitle(0, bookmark, new_title);
301 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
302 ASSERT_TRUE(AllModelsMatchVerifier());
303
304 SetTitle(0, bookmark, title);
305 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
306 ASSERT_TRUE(AllModelsMatchVerifier());
307 }
308
309 // Test Scribe ID - 371823 - Renaming the same bookmark URL twice.
310 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
311 SC_TwiceRenamingBookmarkURL) {
312 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
313 ASSERT_TRUE(AllModelsMatchVerifier());
314
315 GURL url = GURL(IndexedURL(1));
316 const BookmarkNode* bookmark = AddURL(0, kGenericURLTitle, url);
317 ASSERT_TRUE(bookmark != NULL);
318 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
319 ASSERT_TRUE(AllModelsMatchVerifier());
320
321 GURL new_url = GURL(IndexedURL(2));
322 ASSERT_TRUE(SetURL(0, bookmark, new_url) != NULL);
323 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
324 ASSERT_TRUE(AllModelsMatchVerifier());
325
326 ASSERT_TRUE(SetURL(0, bookmark, url) != NULL);
327 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
328 ASSERT_TRUE(AllModelsMatchVerifier());
329 }
330
331 // Test Scribe ID - 371824.
332 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMFolder) {
333 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
334 ASSERT_TRUE(AllModelsMatchVerifier());
335
336 std::wstring title = IndexedFolderName(1);
337 const BookmarkNode* folder = AddFolder(0, title);
338 ASSERT_TRUE(AddURL(
339 0, folder, 0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
340 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
341 ASSERT_TRUE(AllModelsMatchVerifier());
342
343 std::wstring new_title = IndexedFolderName(2);
344 SetTitle(0, folder, new_title);
345 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
346 ASSERT_TRUE(AllModelsMatchVerifier());
347 }
348
349 // Test Scribe ID - 371825.
350 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameEmptyBMFolder) {
351 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
352 ASSERT_TRUE(AllModelsMatchVerifier());
353
354 std::wstring title = IndexedFolderName(1);
355 const BookmarkNode* folder = AddFolder(0, title);
356 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
357 ASSERT_TRUE(AllModelsMatchVerifier());
358
359 std::wstring new_title = IndexedFolderName(2);
360 SetTitle(0, folder, new_title);
361 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
362 ASSERT_TRUE(AllModelsMatchVerifier());
363 }
364
365 // Test Scribe ID - 371826.
366 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
367 SC_RenameBMFolderWithLongHierarchy) {
368 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
369 ASSERT_TRUE(AllModelsMatchVerifier());
370
371 std::wstring title = IndexedFolderName(1);
372 const BookmarkNode* folder = AddFolder(0, title);
373 ASSERT_TRUE(folder != NULL);
374 for (int i = 0; i < 120; ++i) {
375 if (base::RandDouble() > 0.15) {
376 std::wstring title = IndexedURLTitle(i);
377 GURL url = GURL(IndexedURL(i));
378 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
379 } else {
380 std::wstring title = IndexedSubfolderName(i);
381 ASSERT_TRUE(AddFolder(0, folder, i, title) != NULL);
382 }
383 }
384 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
385 ASSERT_TRUE(AllModelsMatchVerifier());
386
387 std::wstring new_title = IndexedFolderName(2);
388 SetTitle(0, folder, new_title);
389 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
390 ASSERT_TRUE(AllModelsMatchVerifier());
391 }
392
393 // Test Scribe ID - 371827.
394 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
395 SC_RenameBMFolderThatHasParentAndChildren) {
396 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
397 ASSERT_TRUE(AllModelsMatchVerifier());
398
399 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
400 ASSERT_TRUE(folder != NULL);
401 for (int i = 1; i < 15; ++i) {
402 std::wstring title = IndexedURLTitle(i);
403 GURL url = GURL(IndexedURL(i));
404 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
405 }
406 std::wstring title = IndexedSubfolderName(1);
407 const BookmarkNode* subfolder = AddFolder(0, folder, 0, title);
408 for (int i = 0; i < 120; ++i) {
409 if (base::RandDouble() > 0.15) {
410 std::wstring title = IndexedURLTitle(i);
411 GURL url = GURL(IndexedURL(i));
412 ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
413 } else {
414 std::wstring title = IndexedSubsubfolderName(i);
415 ASSERT_TRUE(AddFolder(0, subfolder, i, title) != NULL);
416 }
417 }
418 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
419 ASSERT_TRUE(AllModelsMatchVerifier());
420
421 std::wstring new_title = IndexedSubfolderName(2);
422 SetTitle(0, subfolder, new_title);
423 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
424 ASSERT_TRUE(AllModelsMatchVerifier());
425 }
426
427 // Test Scribe ID - 371828.
428 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_RenameBMNameAndURL) {
429 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
430 ASSERT_TRUE(AllModelsMatchVerifier());
431
432 GURL url = GURL(IndexedURL(1));
433 std::wstring title = IndexedURLTitle(1);
434 const BookmarkNode* bookmark = AddURL(0, title, url);
435 ASSERT_TRUE(bookmark != NULL);
436 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
437 ASSERT_TRUE(AllModelsMatchVerifier());
438
439 GURL new_url = GURL(IndexedURL(2));
440 std::wstring new_title = IndexedURLTitle(2);
441 bookmark = SetURL(0, bookmark, new_url);
442 ASSERT_TRUE(bookmark != NULL);
443 SetTitle(0, bookmark, new_title);
444 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
445 ASSERT_TRUE(AllModelsMatchVerifier());
446 }
447
448 // Test Scribe ID - 371832.
449 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
450 SC_DeleteBMEmptyAccountAfterwards) {
451 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
452 ASSERT_TRUE(AllModelsMatchVerifier());
453
454 ASSERT_TRUE(AddURL(
455 0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
456 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
457 ASSERT_TRUE(AllModelsMatchVerifier());
458
459 Remove(0, GetBookmarkBarNode(0), 0);
460 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
461 ASSERT_TRUE(AllModelsMatchVerifier());
462 }
463
464 // Test Scribe ID - 371833.
465 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
466 SC_DelBMNonEmptyAccountAfterwards) {
467 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
468 ASSERT_TRUE(AllModelsMatchVerifier());
469
470 for (int i = 0; i < 20; ++i) {
471 std::wstring title = IndexedURLTitle(i);
472 GURL url = GURL(IndexedURL(i));
473 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
474 }
475 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
476 ASSERT_TRUE(AllModelsMatchVerifier());
477
478 Remove(0, GetBookmarkBarNode(0), 0);
479 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
480 ASSERT_TRUE(AllModelsMatchVerifier());
481 }
482
483 // Test Scribe ID - 371835.
484 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
485 SC_DelFirstBMUnderBMFoldNonEmptyFoldAfterwards) {
486 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
487 ASSERT_TRUE(AllModelsMatchVerifier());
488
489 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
490 ASSERT_TRUE(folder != NULL);
491 for (int i = 0; i < 10; ++i) {
492 std::wstring title = IndexedURLTitle(i);
493 GURL url = GURL(IndexedURL(i));
494 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
495 }
496 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
497 ASSERT_TRUE(AllModelsMatchVerifier());
498
499 Remove(0, folder, 0);
500 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
501 ASSERT_TRUE(AllModelsMatchVerifier());
502 }
503
504 // Test Scribe ID - 371836.
505 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
506 SC_DelLastBMUnderBMFoldNonEmptyFoldAfterwards) {
507 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
508 ASSERT_TRUE(AllModelsMatchVerifier());
509
510 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
511 ASSERT_TRUE(folder != NULL);
512 for (int i = 0; i < 10; ++i) {
513 std::wstring title = IndexedURLTitle(i);
514 GURL url = GURL(IndexedURL(i));
515 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
516 }
517 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
518 ASSERT_TRUE(AllModelsMatchVerifier());
519
520 Remove(0, folder, folder->child_count() - 1);
521 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
522 ASSERT_TRUE(AllModelsMatchVerifier());
523 }
524
525 // Test Scribe ID - 371856.
526 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
527 SC_DelMiddleBMUnderBMFoldNonEmptyFoldAfterwards) {
528 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
529 ASSERT_TRUE(AllModelsMatchVerifier());
530
531 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
532 ASSERT_TRUE(folder != NULL);
533 for (int i = 0; i < 10; ++i) {
534 std::wstring title = IndexedURLTitle(i);
535 GURL url = GURL(IndexedURL(i));
536 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
537 }
538 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
539 ASSERT_TRUE(AllModelsMatchVerifier());
540
541 Remove(0, folder, 4);
542 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
543 ASSERT_TRUE(AllModelsMatchVerifier());
544 }
545
546 // Test Scribe ID - 371857.
547 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
548 SC_DelBMsUnderBMFoldEmptyFolderAfterwards) {
549 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
550 ASSERT_TRUE(AllModelsMatchVerifier());
551
552 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
553 ASSERT_TRUE(folder != NULL);
554 for (int i = 0; i < 10; ++i) {
555 std::wstring title = IndexedURLTitle(i);
556 GURL url = GURL(IndexedURL(i));
557 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
558 }
559 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
560 ASSERT_TRUE(AllModelsMatchVerifier());
561
562 int child_count = folder->child_count();
563 for (int i = 0; i < child_count; ++i) {
564 Remove(0, folder, 0);
565 }
566 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
567 ASSERT_TRUE(AllModelsMatchVerifier());
568 }
569
570 // Test Scribe ID - 371858.
571 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
572 SC_DelEmptyBMFoldEmptyAccountAfterwards) {
573 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
574 ASSERT_TRUE(AllModelsMatchVerifier());
575
576 ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
577 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
578 ASSERT_TRUE(AllModelsMatchVerifier());
579
580 Remove(0, GetBookmarkBarNode(0), 0);
581 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
582 ASSERT_TRUE(AllModelsMatchVerifier());
583 }
584
585 // Test Scribe ID - 371869.
586 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
587 SC_DelEmptyBMFoldNonEmptyAccountAfterwards) {
588 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
589 ASSERT_TRUE(AllModelsMatchVerifier());
590
591 ASSERT_TRUE(AddFolder(0, kGenericFolderName) != NULL);
592 for (int i = 1; i < 15; ++i) {
593 if (base::RandDouble() > 0.6) {
594 std::wstring title = IndexedURLTitle(i);
595 GURL url = GURL(IndexedURL(i));
596 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
597 } else {
598 std::wstring title = IndexedFolderName(i);
599 ASSERT_TRUE(AddFolder(0, i, title) != NULL);
600 }
601 }
602 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
603 ASSERT_TRUE(AllModelsMatchVerifier());
604
605 Remove(0, GetBookmarkBarNode(0), 0);
606 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
607 ASSERT_TRUE(AllModelsMatchVerifier());
608 }
609
610 // Test Scribe ID - 371879.
611 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
612 SC_DelBMFoldWithBMsNonEmptyAccountAfterwards) {
613 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
614 ASSERT_TRUE(AllModelsMatchVerifier());
615
616 ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
617 const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
618 ASSERT_TRUE(folder != NULL);
619 for (int i = 2; i < 10; ++i) {
620 if (base::RandDouble() > 0.6) {
621 std::wstring title = IndexedURLTitle(i);
622 GURL url = GURL(IndexedURL(i));
623 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
624 } else {
625 std::wstring title = IndexedFolderName(i);
626 ASSERT_TRUE(AddFolder(0, i, title) != NULL);
627 }
628 }
629 for (int i = 0; i < 15; ++i) {
630 std::wstring title = IndexedURLTitle(i);
631 GURL url = GURL(IndexedURL(i));
632 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
633 }
634 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
635 ASSERT_TRUE(AllModelsMatchVerifier());
636
637 Remove(0, GetBookmarkBarNode(0), 1);
638 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
639 ASSERT_TRUE(AllModelsMatchVerifier());
640 }
641
642 // Test Scribe ID - 371880.
643 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
644 SC_DelBMFoldWithBMsAndBMFoldsNonEmptyACAfterwards) {
645 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
646 ASSERT_TRUE(AllModelsMatchVerifier());
647
648 ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
649 const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
650 ASSERT_TRUE(folder != NULL);
651 for (int i = 2; i < 10; ++i) {
652 if (base::RandDouble() > 0.6) {
653 std::wstring title = IndexedURLTitle(i);
654 GURL url = GURL(IndexedURL(i));
655 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
656 } else {
657 std::wstring title = IndexedFolderName(i);
658 ASSERT_TRUE(AddFolder(0, i, title) != NULL);
659 }
660 }
661 for (int i = 0; i < 10; ++i) {
662 if (base::RandDouble() > 0.6) {
663 std::wstring title = IndexedURLTitle(i);
664 GURL url = GURL(IndexedURL(i));
665 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
666 } else {
667 std::wstring title = IndexedSubfolderName(i);
668 const BookmarkNode* subfolder =
669 AddFolder(0, folder, i, title);
670 ASSERT_TRUE(subfolder != NULL);
671 if (base::RandDouble() > 0.3) {
672 for (int j = 0; j < 10; ++j) {
673 if (base::RandDouble() > 0.6) {
674 std::wstring title = IndexedURLTitle(j);
675 GURL url = GURL(IndexedURL(j));
676 ASSERT_TRUE(AddURL(
677 0, subfolder, j, title, url) != NULL);
678 } else {
679 std::wstring title = IndexedSubsubfolderName(j);
680 ASSERT_TRUE(AddFolder(
681 0, subfolder, j, title) != NULL);
682 }
683 }
684 }
685 }
686 }
687 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
688 ASSERT_TRUE(AllModelsMatchVerifier());
689
690 Remove(0, GetBookmarkBarNode(0), 1);
691 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
692 ASSERT_TRUE(AllModelsMatchVerifier());
693 }
694
695 // Test Scribe ID - 371882.
696 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
697 SC_DelBMFoldWithParentAndChildrenBMsAndBMFolds) {
698 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
699 ASSERT_TRUE(AllModelsMatchVerifier());
700
701 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
702 ASSERT_TRUE(folder != NULL);
703 for (int i = 1; i < 11; ++i) {
704 std::wstring title = IndexedURLTitle(i);
705 GURL url = GURL(IndexedURL(i));
706 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
707 }
708 const BookmarkNode* subfolder =
709 AddFolder(0, folder, 0, kGenericSubfolderName);
710 ASSERT_TRUE(subfolder != NULL);
711 for (int i = 0; i < 30; ++i) {
712 if (base::RandDouble() > 0.2) {
713 std::wstring title = IndexedURLTitle(i);
714 GURL url = GURL(IndexedURL(i));
715 ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
716 } else {
717 std::wstring title = IndexedSubsubfolderName(i);
718 ASSERT_TRUE(AddFolder(0, subfolder, i, title) != NULL);
719 }
720 }
721 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
722 ASSERT_TRUE(AllModelsMatchVerifier());
723
724 Remove(0, folder, 0);
725 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
726 ASSERT_TRUE(AllModelsMatchVerifier());
727 }
728
729 // Test Scribe ID - 371931.
730 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
731 SC_ReverseTheOrderOfTwoBMs) {
732 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
733 ASSERT_TRUE(AllModelsMatchVerifier());
734
735 GURL url0 = GURL(IndexedURL(0));
736 GURL url1 = GURL(IndexedURL(1));
737 std::wstring title0 = IndexedURLTitle(0);
738 std::wstring title1 = IndexedURLTitle(1);
739 const BookmarkNode* bookmark0 = AddURL(0, 0, title0, url0);
740 const BookmarkNode* bookmark1 = AddURL(0, 1, title1, url1);
741 ASSERT_TRUE(bookmark0 != NULL);
742 ASSERT_TRUE(bookmark1 != NULL);
743 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
744 ASSERT_TRUE(AllModelsMatchVerifier());
745
746 Move(0, bookmark0, GetBookmarkBarNode(0), 2);
747 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
748 ASSERT_TRUE(AllModelsMatchVerifier());
749 }
750
751 // Test Scribe ID - 371933.
752 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_ReverseTheOrderOf10BMs) {
753 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
754 ASSERT_TRUE(AllModelsMatchVerifier());
755
756 for (int i = 0; i < 10; ++i) {
757 std::wstring title = IndexedURLTitle(i);
758 GURL url = GURL(IndexedURL(i));
759 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
760 }
761 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
762 ASSERT_TRUE(AllModelsMatchVerifier());
763
764 ReverseChildOrder(0, GetBookmarkBarNode(0));
765 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
766 ASSERT_TRUE(AllModelsMatchVerifier());
767 }
768
769 // Test Scribe ID - 371954.
770 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
771 SC_MovingBMsFromBMBarToBMFolder) {
772 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
773 ASSERT_TRUE(AllModelsMatchVerifier());
774
775 ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
776 const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
777 ASSERT_TRUE(folder != NULL);
778 for (int i = 2; i < 10; ++i) {
779 std::wstring title = IndexedURLTitle(i);
780 GURL url = GURL(IndexedURL(i));
781 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
782 }
783 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
784 ASSERT_TRUE(AllModelsMatchVerifier());
785
786 int num_bookmarks_to_move =
787 GetBookmarkBarNode(0)->child_count() - 2;
788 for (int i = 0; i < num_bookmarks_to_move; ++i) {
789 Move(
790 0, GetBookmarkBarNode(0)->GetChild(2), folder, i);
791 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
792 ASSERT_TRUE(AllModelsMatchVerifier());
793 }
794 }
795
796 // Test Scribe ID - 371957.
797 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
798 SC_MovingBMsFromBMFoldToBMBar) {
799 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
800 ASSERT_TRUE(AllModelsMatchVerifier());
801
802 ASSERT_TRUE(AddURL(0, kGenericURLTitle, GURL(kGenericURL)) != NULL);
803 const BookmarkNode* folder = AddFolder(0, 1, kGenericFolderName);
804 ASSERT_TRUE(folder != NULL);
805 for (int i = 0; i < 10; ++i) {
806 std::wstring title = IndexedURLTitle(i);
807 GURL url = GURL(IndexedURL(i));
808 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
809 }
810 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
811 ASSERT_TRUE(AllModelsMatchVerifier());
812
813 int num_bookmarks_to_move = folder->child_count() - 2;
814 for (int i = 0; i < num_bookmarks_to_move; ++i) {
815 Move(0, folder->GetChild(0), GetBookmarkBarNode(0), i);
816 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
817 ASSERT_TRUE(AllModelsMatchVerifier());
818 }
819 }
820
821 // Test Scribe ID - 371961.
822 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
823 SC_MovingBMsFromParentBMFoldToChildBMFold) {
824 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
825 ASSERT_TRUE(AllModelsMatchVerifier());
826
827 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
828 ASSERT_TRUE(folder != NULL);
829 for (int i = 0; i < 3; ++i) {
830 std::wstring title = IndexedURLTitle(i);
831 GURL url = GURL(IndexedURL(i));
832 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
833 }
834 const BookmarkNode* subfolder =
835 AddFolder(0, folder, 3, kGenericSubfolderName);
836 ASSERT_TRUE(subfolder != NULL);
837 for (int i = 0; i < 10; ++i) {
838 std::wstring title = IndexedURLTitle(i + 3);
839 GURL url = GURL(IndexedURL(i + 3));
840 ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
841 }
842 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
843 ASSERT_TRUE(AllModelsMatchVerifier());
844
845 for (int i = 0; i < 3; ++i) {
846 GURL url = GURL(IndexedURL(i));
847 Move(0, GetUniqueNodeByURL(0, url), subfolder, i + 10);
848 }
849 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
850 ASSERT_TRUE(AllModelsMatchVerifier());
851 }
852
853 // Test Scribe ID - 371964.
854 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
855 SC_MovingBMsFromChildBMFoldToParentBMFold) {
856 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
857 ASSERT_TRUE(AllModelsMatchVerifier());
858
859 const BookmarkNode* folder = AddFolder(0, kGenericFolderName);
860 ASSERT_TRUE(folder != NULL);
861 for (int i = 0; i < 3; ++i) {
862 std::wstring title = IndexedURLTitle(i);
863 GURL url = GURL(IndexedURL(i));
864 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
865 }
866 const BookmarkNode* subfolder =
867 AddFolder(0, folder, 3, kGenericSubfolderName);
868 ASSERT_TRUE(subfolder != NULL);
869 for (int i = 0; i < 5; ++i) {
870 std::wstring title = IndexedURLTitle(i + 3);
871 GURL url = GURL(IndexedURL(i + 3));
872 ASSERT_TRUE(AddURL(0, subfolder, i, title, url) != NULL);
873 }
874 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
875 ASSERT_TRUE(AllModelsMatchVerifier());
876
877 for (int i = 0; i < 3; ++i) {
878 GURL url = GURL(IndexedURL(i + 3));
879 Move(0, GetUniqueNodeByURL(0, url), folder, i + 4);
880 }
881 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
882 ASSERT_TRUE(AllModelsMatchVerifier());
883 }
884
885 // Test Scribe ID - 371967.
886 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_HoistBMs10LevelUp) {
887 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
888 ASSERT_TRUE(AllModelsMatchVerifier());
889
890 const BookmarkNode* folder = GetBookmarkBarNode(0);
891 const BookmarkNode* folder_L0 = NULL;
892 const BookmarkNode* folder_L10 = NULL;
893 for (int level = 0; level < 15; ++level) {
894 int num_bookmarks = base::RandInt(0, 9);
895 for (int i = 0; i < num_bookmarks; ++i) {
896 std::wstring title = IndexedURLTitle(i);
897 GURL url = GURL(IndexedURL(i));
898 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
899 }
900 std::wstring title = IndexedFolderName(level);
901 folder = AddFolder(0, folder, folder->child_count(), title);
902 ASSERT_TRUE(folder != NULL);
903 if (level == 0) folder_L0 = folder;
904 if (level == 10) folder_L10 = folder;
905 }
906 for (int i = 0; i < 3; ++i) {
907 std::wstring title = IndexedURLTitle(i + 10);
908 GURL url = GURL(IndexedURL(i + 10));
909 ASSERT_TRUE(AddURL(0, folder_L10, i, title, url) != NULL);
910 }
911 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
912 ASSERT_TRUE(AllModelsMatchVerifier());
913
914 GURL url10 = GURL(IndexedURL(10));
915 Move(0, GetUniqueNodeByURL(
916 0, url10), folder_L0, folder_L0->child_count());
917 GURL url11 = GURL(IndexedURL(11));
918 Move(0, GetUniqueNodeByURL(0, url11), folder_L0, 0);
919 GURL url12 = GURL(IndexedURL(12));
920 Move(0, GetUniqueNodeByURL(0, url12), folder_L0, 1);
921 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
922 ASSERT_TRUE(AllModelsMatchVerifier());
923 }
924
925 // Test Scribe ID - 371968.
926 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, SC_SinkBMs10LevelDown) {
927 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
928 ASSERT_TRUE(AllModelsMatchVerifier());
929
930 const BookmarkNode* folder = GetBookmarkBarNode(0);
931 const BookmarkNode* folder_L0 = NULL;
932 const BookmarkNode* folder_L10 = NULL;
933 for (int level = 0; level < 15; ++level) {
934 int num_bookmarks = base::RandInt(0, 9);
935 for (int i = 0; i < num_bookmarks; ++i) {
936 std::wstring title = IndexedURLTitle(i);
937 GURL url = GURL(IndexedURL(i));
938 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
939 }
940 std::wstring title = IndexedFolderName(level);
941 folder = AddFolder(0, folder, folder->child_count(), title);
942 ASSERT_TRUE(folder != NULL);
943 if (level == 0) folder_L0 = folder;
944 if (level == 10) folder_L10 = folder;
945 }
946 for (int i = 0; i < 3; ++i) {
947 std::wstring title = IndexedURLTitle(i + 10);
948 GURL url = GURL(IndexedURL(i + 10));
949 ASSERT_TRUE(AddURL(0, folder_L0, 0, title, url) != NULL);
950 }
951 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
952 ASSERT_TRUE(AllModelsMatchVerifier());
953
954 GURL url10 = GURL(IndexedURL(10));
955 Move(0, GetUniqueNodeByURL(0, url10), folder_L10, folder_L10->child_count());
956 GURL url11 = GURL(IndexedURL(11));
957 Move(0, GetUniqueNodeByURL(0, url11), folder_L10, 0);
958 GURL url12 = GURL(IndexedURL(12));
959 Move(0, GetUniqueNodeByURL(0, url12), folder_L10, 1);
960 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
961 ASSERT_TRUE(AllModelsMatchVerifier());
962 }
963
964 // Test Scribe ID - 371980.
965 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
966 SC_SinkEmptyBMFold5LevelsDown) {
967 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
968 ASSERT_TRUE(AllModelsMatchVerifier());
969
970 const BookmarkNode* folder = GetBookmarkBarNode(0);
971 const BookmarkNode* folder_L5 = NULL;
972 for (int level = 0; level < 15; ++level) {
973 int num_bookmarks = base::RandInt(0, 9);
974 for (int i = 0; i < num_bookmarks; ++i) {
975 std::wstring title = IndexedURLTitle(i);
976 GURL url = GURL(IndexedURL(i));
977 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
978 }
979 std::wstring title = IndexedFolderName(level);
980 folder = AddFolder(
981 0, folder, folder->child_count(), title);
982 ASSERT_TRUE(folder != NULL);
983 if (level == 5) folder_L5 = folder;
984 }
985 folder = AddFolder(
986 0, GetBookmarkBarNode(0)->child_count(), kGenericFolderName);
987 ASSERT_TRUE(folder != NULL);
988 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
989 ASSERT_TRUE(AllModelsMatchVerifier());
990
991 Move(0, folder, folder_L5, folder_L5->child_count());
992 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
993 ASSERT_TRUE(AllModelsMatchVerifier());
994 }
995
996 // Test Scribe ID - 371997.
997 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
998 SC_SinkNonEmptyBMFold5LevelsDown) {
999 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1000 ASSERT_TRUE(AllModelsMatchVerifier());
1001
1002 const BookmarkNode* folder = GetBookmarkBarNode(0);
1003 const BookmarkNode* folder_L5 = NULL;
1004 for (int level = 0; level < 6; ++level) {
1005 int num_bookmarks = base::RandInt(0, 9);
1006 for (int i = 0; i < num_bookmarks; ++i) {
1007 std::wstring title = IndexedURLTitle(i);
1008 GURL url = GURL(IndexedURL(i));
1009 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1010 }
1011 std::wstring title = IndexedFolderName(level);
1012 folder = AddFolder(0, folder, folder->child_count(), title);
1013 ASSERT_TRUE(folder != NULL);
1014 if (level == 5) folder_L5 = folder;
1015 }
1016 folder = AddFolder(
1017 0, GetBookmarkBarNode(0)->child_count(), kGenericFolderName);
1018 ASSERT_TRUE(folder != NULL);
1019 for (int i = 0; i < 10; ++i) {
1020 std::wstring title = IndexedURLTitle(i);
1021 GURL url = GURL(IndexedURL(i));
1022 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1023 }
1024 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1025 ASSERT_TRUE(AllModelsMatchVerifier());
1026
1027 Move(0, folder, folder_L5, folder_L5->child_count());
1028 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1029 ASSERT_TRUE(AllModelsMatchVerifier());
1030 }
1031
1032 // Test Scribe ID - 372006.
1033 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1034 SC_HoistFolder5LevelsUp) {
1035 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1036 ASSERT_TRUE(AllModelsMatchVerifier());
1037
1038 const BookmarkNode* folder = GetBookmarkBarNode(0);
1039 const BookmarkNode* folder_L5 = NULL;
1040 for (int level = 0; level < 6; ++level) {
1041 int num_bookmarks = base::RandInt(0, 9);
1042 for (int i = 0; i < num_bookmarks; ++i) {
1043 std::wstring title = IndexedURLTitle(i);
1044 GURL url = GURL(IndexedURL(i));
1045 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1046 }
1047 std::wstring title = IndexedFolderName(level);
1048 folder = AddFolder(
1049 0, folder, folder->child_count(), title);
1050 ASSERT_TRUE(folder != NULL);
1051 if (level == 5) folder_L5 = folder;
1052 }
1053 folder = AddFolder(
1054 0, folder_L5, folder_L5->child_count(), kGenericFolderName);
1055 ASSERT_TRUE(folder != NULL);
1056 for (int i = 0; i < 10; ++i) {
1057 std::wstring title = IndexedURLTitle(i);
1058 GURL url = GURL(IndexedURL(i));
1059 ASSERT_TRUE(AddURL(0, folder, i, title, url) != NULL);
1060 }
1061 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1062 ASSERT_TRUE(AllModelsMatchVerifier());
1063
1064 Move(0, folder, GetBookmarkBarNode(0), GetBookmarkBarNode(0)->child_count());
1065 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1066 ASSERT_TRUE(AllModelsMatchVerifier());
1067 }
1068
1069 // Test Scribe ID - 372026.
1070 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1071 SC_ReverseTheOrderOfTwoBMFolders) {
1072 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1073 ASSERT_TRUE(AllModelsMatchVerifier());
1074
1075 for (int i = 0; i < 2; ++i) {
1076 std::wstring title = IndexedFolderName(i);
1077 const BookmarkNode* folder = AddFolder(0, i, title);
1078 ASSERT_TRUE(folder != NULL);
1079 for (int j = 0; j < 10; ++j) {
1080 std::wstring title = IndexedURLTitle(j);
1081 GURL url = GURL(IndexedURL(j));
1082 ASSERT_TRUE(AddURL(0, folder, j, title, url) != NULL);
1083 }
1084 }
1085 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1086 ASSERT_TRUE(AllModelsMatchVerifier());
1087
1088 ReverseChildOrder(0, GetBookmarkBarNode(0));
1089 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1090 ASSERT_TRUE(AllModelsMatchVerifier());
1091 }
1092
1093 // Test Scribe ID - 372028.
1094 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1095 SC_ReverseTheOrderOfTenBMFolders) {
1096 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1097 ASSERT_TRUE(AllModelsMatchVerifier());
1098
1099 for (int i = 0; i < 10; ++i) {
1100 std::wstring title = IndexedFolderName(i);
1101 const BookmarkNode* folder = AddFolder(0, i, title);
1102 ASSERT_TRUE(folder != NULL);
1103 for (int j = 0; j < 10; ++j) {
1104 std::wstring title = IndexedURLTitle(1000 * i + j);
1105 GURL url = GURL(IndexedURL(j));
1106 ASSERT_TRUE(AddURL(0, folder, j, title, url) != NULL);
1107 }
1108 }
1109 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1110 ASSERT_TRUE(AllModelsMatchVerifier());
1111
1112 ReverseChildOrder(0, GetBookmarkBarNode(0));
1113 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1114 ASSERT_TRUE(AllModelsMatchVerifier());
1115 }
1116
1117 // Test Scribe ID - 373379.
1118 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1119 MC_BiDirectionalPushAddingBM) {
1120 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1121 ASSERT_TRUE(AllModelsMatchVerifier());
1122
1123 DisableVerifier();
1124 for (int i = 0; i < 2; ++i) {
1125 std::wstring title0 = IndexedURLTitle(2*i);
1126 GURL url0 = GURL(IndexedURL(2*i));
1127 ASSERT_TRUE(AddURL(0, title0, url0) != NULL);
1128 std::wstring title1 = IndexedURLTitle(2*i+1);
1129 GURL url1 = GURL(IndexedURL(2*i+1));
1130 ASSERT_TRUE(AddURL(1, title1, url1) != NULL);
1131 }
1132 ASSERT_TRUE(AwaitQuiescence());
1133 ASSERT_TRUE(AllModelsMatch());
1134 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1135 }
1136
1137 // Test Scribe ID - 373503.
1138 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1139 MC_BiDirectionalPush_AddingSameBMs) {
1140 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1141 ASSERT_TRUE(AllModelsMatchVerifier());
1142
1143 // Note: When a racy commit is done with identical bookmarks, it is possible
1144 // for duplicates to exist after sync completes. See http://crbug.com/19769.
1145 DisableVerifier();
1146 for (int i = 0; i < 2; ++i) {
1147 std::wstring title = IndexedURLTitle(i);
1148 GURL url = GURL(IndexedURL(i));
1149 ASSERT_TRUE(AddURL(0, title, url) != NULL);
1150 ASSERT_TRUE(AddURL(1, title, url) != NULL);
1151 }
1152 ASSERT_TRUE(AwaitQuiescence());
1153 ASSERT_TRUE(AllModelsMatch());
1154 }
1155
1156 // Test Scribe ID - 373506.
1157 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1158 MC_BootStrapEmptyStateEverywhere) {
1159 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1160 ASSERT_TRUE(AwaitQuiescence());
1161 ASSERT_TRUE(AllModelsMatchVerifier());
1162 }
1163
1164 // Test Scribe ID - 373505.
1165 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1166 MC_Merge_CaseInsensitivity_InNames) {
1167 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1168 DisableVerifier();
1169
1170 const BookmarkNode* folder0 = AddFolder(0, L"Folder");
1171 ASSERT_TRUE(folder0 != NULL);
1172 ASSERT_TRUE(AddURL(0, folder0, 0, L"Bookmark 0", GURL(kGenericURL)) != NULL);
1173 ASSERT_TRUE(AddURL(0, folder0, 1, L"Bookmark 1", GURL(kGenericURL)) != NULL);
1174 ASSERT_TRUE(AddURL(0, folder0, 2, L"Bookmark 2", GURL(kGenericURL)) != NULL);
1175
1176 const BookmarkNode* folder1 = AddFolder(1, L"fOlDeR");
1177 ASSERT_TRUE(folder1 != NULL);
1178 ASSERT_TRUE(AddURL(1, folder1, 0, L"bOoKmArK 0", GURL(kGenericURL)) != NULL);
1179 ASSERT_TRUE(AddURL(1, folder1, 1, L"BooKMarK 1", GURL(kGenericURL)) != NULL);
1180 ASSERT_TRUE(AddURL(1, folder1, 2, L"bOOKMARK 2", GURL(kGenericURL)) != NULL);
1181
1182 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1183 ASSERT_TRUE(AwaitQuiescence());
1184 ASSERT_TRUE(AllModelsMatch());
1185 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1186 }
1187
1188 // Test Scribe ID - 373508.
1189 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1190 MC_SimpleMergeOfDifferentBMModels) {
1191 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1192 DisableVerifier();
1193
1194 for (int i = 0; i < 3; ++i) {
1195 std::wstring title = IndexedURLTitle(i);
1196 GURL url = GURL(IndexedURL(i));
1197 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1198 ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1199 }
1200
1201 for (int i = 3; i < 10; ++i) {
1202 std::wstring title0 = IndexedURLTitle(i);
1203 GURL url0 = GURL(IndexedURL(i));
1204 ASSERT_TRUE(AddURL(0, i, title0, url0) != NULL);
1205 std::wstring title1 = IndexedURLTitle(i+7);
1206 GURL url1 = GURL(IndexedURL(i+7));
1207 ASSERT_TRUE(AddURL(1, i, title1, url1) != NULL);
1208 }
1209
1210 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1211 ASSERT_TRUE(AwaitQuiescence());
1212 ASSERT_TRUE(AllModelsMatch());
1213 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1214 }
1215
1216 // Test Scribe ID - 386586.
1217 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1218 MC_MergeSimpleBMHierarchyUnderBMBar) {
1219 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1220 DisableVerifier();
1221
1222 for (int i = 0; i < 3; ++i) {
1223 std::wstring title = IndexedURLTitle(i);
1224 GURL url = GURL(IndexedURL(i));
1225 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1226 ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1227 }
1228
1229 for (int i = 3; i < 10; ++i) {
1230 std::wstring title = IndexedURLTitle(i);
1231 GURL url = GURL(IndexedURL(i));
1232 ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1233 }
1234
1235 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1236 ASSERT_TRUE(AwaitQuiescence());
1237 ASSERT_TRUE(AllModelsMatch());
1238 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1239 }
1240
1241 // Test Scribe ID - 386589.
1242 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1243 MC_MergeSimpleBMHierarchyEqualSetsUnderBMBar) {
1244 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1245 DisableVerifier();
1246
1247 for (int i = 0; i < 3; ++i) {
1248 std::wstring title = IndexedURLTitle(i);
1249 GURL url = GURL(IndexedURL(i));
1250 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1251 ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1252 }
1253
1254 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1255 ASSERT_TRUE(AwaitQuiescence());
1256 ASSERT_TRUE(AllModelsMatch());
1257 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1258 }
1259
1260 // Test Scribe ID - 373504 - Merge bookmark folders with different bookmarks.
1261 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1262 MC_MergeBMFoldersWithDifferentBMs) {
1263 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1264 DisableVerifier();
1265
1266 const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1267 ASSERT_TRUE(folder0 != NULL);
1268 const BookmarkNode* folder1 = AddFolder(1, kGenericFolderName);
1269 ASSERT_TRUE(folder1 != NULL);
1270 for (int i = 0; i < 2; ++i) {
1271 std::wstring title0 = IndexedURLTitle(2*i);
1272 GURL url0 = GURL(IndexedURL(2*i));
1273 ASSERT_TRUE(AddURL(0, folder0, i, title0, url0) != NULL);
1274 std::wstring title1 = IndexedURLTitle(2*i+1);
1275 GURL url1 = GURL(IndexedURL(2*i+1));
1276 ASSERT_TRUE(AddURL(1, folder1, i, title1, url1) != NULL);
1277 }
1278 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1279 ASSERT_TRUE(AwaitQuiescence());
1280 ASSERT_TRUE(AllModelsMatch());
1281 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1282 }
1283
1284 // Test Scribe ID - 373509 - Merge moderately complex bookmark models.
1285 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1286 MC_MergeDifferentBMModelsModeratelyComplex) {
1287 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1288 DisableVerifier();
1289
1290 for (int i = 0; i < 25; ++i) {
1291 std::wstring title0 = IndexedURLTitle(i);
1292 GURL url0 = GURL(IndexedURL(i));
1293 ASSERT_TRUE(AddURL(0, i, title0, url0) != NULL);
1294 std::wstring title1 = IndexedURLTitle(i+50);
1295 GURL url1 = GURL(IndexedURL(i+50));
1296 ASSERT_TRUE(AddURL(1, i, title1, url1) != NULL);
1297 }
1298 for (int i = 25; i < 30; ++i) {
1299 std::wstring title0 = IndexedFolderName(i);
1300 const BookmarkNode* folder0 = AddFolder(0, i, title0);
1301 ASSERT_TRUE(folder0 != NULL);
1302 std::wstring title1 = IndexedFolderName(i+50);
1303 const BookmarkNode* folder1 = AddFolder(1, i, title1);
1304 ASSERT_TRUE(folder1 != NULL);
1305 for (int j = 0; j < 5; ++j) {
1306 std::wstring title0 = IndexedURLTitle(i+5*j);
1307 GURL url0 = GURL(IndexedURL(i+5*j));
1308 ASSERT_TRUE(AddURL(0, folder0, j, title0, url0) != NULL);
1309 std::wstring title1 = IndexedURLTitle(i+5*j+50);
1310 GURL url1 = GURL(IndexedURL(i+5*j+50));
1311 ASSERT_TRUE(AddURL(1, folder1, j, title1, url1) != NULL);
1312 }
1313 }
1314 for (int i = 100; i < 125; ++i) {
1315 std::wstring title = IndexedURLTitle(i);
1316 GURL url = GURL(IndexedURL(i));
1317 ASSERT_TRUE(AddURL(0, title, url) != NULL);
1318 ASSERT_TRUE(AddURL(1, title, url) != NULL);
1319 }
1320 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1321 ASSERT_TRUE(AwaitQuiescence());
1322 ASSERT_TRUE(AllModelsMatch());
1323 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1324 }
1325
1326 // TCM ID - 3675271 - Merge simple bookmark subset under bookmark folder.
1327 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1328 MC_MergeSimpleBMHierarchySubsetUnderBMFolder) {
1329 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1330 DisableVerifier();
1331
1332 for (int i = 0; i < 2; ++i) {
1333 const BookmarkNode* folder = AddFolder(i, kGenericFolderName);
1334 ASSERT_TRUE(folder != NULL);
1335 for (int j = 0; j < 4; ++j) {
1336 if (base::RandDouble() < 0.5) {
1337 std::wstring title = IndexedURLTitle(j);
1338 GURL url = GURL(IndexedURL(j));
1339 ASSERT_TRUE(AddURL(i, folder, j, title, url) != NULL);
1340 } else {
1341 std::wstring title = IndexedFolderName(j);
1342 ASSERT_TRUE(AddFolder(i, folder, j, title) != NULL);
1343 }
1344 }
1345 }
1346 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1347 ASSERT_TRUE(AwaitQuiescence());
1348 ASSERT_TRUE(AllModelsMatch());
1349 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1350 }
1351
1352 // TCM ID - 3727284 - Merge subsets of bookmark under bookmark bar.
1353 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1354 MC_MergeSimpleBMHierarchySubsetUnderBookmarkBar) {
1355 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1356 DisableVerifier();
1357
1358 for (int i = 0; i < 4; ++i) {
1359 std::wstring title = IndexedURLTitle(i);
1360 GURL url = GURL(IndexedURL(i));
1361 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1362 }
1363
1364 for (int j = 0; j < 2; ++j) {
1365 std::wstring title = IndexedURLTitle(j);
1366 GURL url = GURL(IndexedURL(j));
1367 ASSERT_TRUE(AddURL(1, j, title, url) != NULL);
1368 }
1369
1370 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1371 ASSERT_TRUE(AwaitQuiescence());
1372 ASSERT_TRUE(AllModelsMatch());
1373 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1374 ASSERT_FALSE(ContainsDuplicateBookmarks(1));
1375 }
1376
1377 // TCM ID - 3659294 - Merge simple bookmark hierarchy under bookmark folder.
1378 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1379 MC_Merge_SimpleBMHierarchy_Under_BMFolder) {
1380 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1381 DisableVerifier();
1382
1383 const BookmarkNode* folder0 = AddFolder(0, 0, kGenericFolderName);
1384 ASSERT_TRUE(folder0 != NULL);
1385 ASSERT_TRUE(AddURL(
1386 0, folder0, 0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1387 ASSERT_TRUE(AddFolder(0, folder0, 1, IndexedSubfolderName(2)) != NULL);
1388 ASSERT_TRUE(AddURL(
1389 0, folder0, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1390 ASSERT_TRUE(AddFolder(0, folder0, 3, IndexedSubfolderName(4)) != NULL);
1391
1392 const BookmarkNode* folder1 = AddFolder(1, 0, kGenericFolderName);
1393 ASSERT_TRUE(folder1 != NULL);
1394 ASSERT_TRUE(AddFolder(1, folder1, 0, IndexedSubfolderName(0)) != NULL);
1395 ASSERT_TRUE(AddFolder(1, folder1, 1, IndexedSubfolderName(2)) != NULL);
1396 ASSERT_TRUE(AddURL(
1397 1, folder1, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1398 ASSERT_TRUE(AddFolder(1, folder1, 3, IndexedSubfolderName(5)) != NULL);
1399 ASSERT_TRUE(AddURL(
1400 1, folder1, 4, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1401
1402 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1403 ASSERT_TRUE(AwaitQuiescence());
1404 ASSERT_TRUE(AllModelsMatch());
1405 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1406 }
1407
1408 // TCM ID - 3711273 - Merge disjoint sets of bookmark hierarchy under bookmark
1409 // folder.
1410 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1411 MC_Merge_SimpleBMHierarchy_DisjointSets_Under_BMFolder) {
1412 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1413 DisableVerifier();
1414
1415 const BookmarkNode* folder0 =
1416 AddFolder(0, 0, kGenericFolderName);
1417 ASSERT_TRUE(folder0 != NULL);
1418 ASSERT_TRUE(AddURL(
1419 0, folder0, 0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1420 ASSERT_TRUE(AddFolder(0, folder0, 1, IndexedSubfolderName(2)) != NULL);
1421 ASSERT_TRUE(AddURL(
1422 0, folder0, 2, IndexedURLTitle(3), GURL(IndexedURL(3))) != NULL);
1423 ASSERT_TRUE(AddFolder(0, folder0, 3, IndexedSubfolderName(4)) != NULL);
1424
1425 const BookmarkNode* folder1 = AddFolder(1, 0, kGenericFolderName);
1426 ASSERT_TRUE(folder1 != NULL);
1427 ASSERT_TRUE(AddFolder(1, folder1, 0, IndexedSubfolderName(5)) != NULL);
1428 ASSERT_TRUE(AddFolder(1, folder1, 1, IndexedSubfolderName(6)) != NULL);
1429 ASSERT_TRUE(AddURL(
1430 1, folder1, 2, IndexedURLTitle(7), GURL(IndexedURL(7))) != NULL);
1431 ASSERT_TRUE(AddURL(
1432 1, folder1, 3, IndexedURLTitle(8), GURL(IndexedURL(8))) != NULL);
1433
1434 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1435 ASSERT_TRUE(AwaitQuiescence());
1436 ASSERT_TRUE(AllModelsMatch());
1437 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1438 }
1439
1440 // TCM ID - 3639296 - Merge disjoint sets of bookmark hierarchy under bookmark
1441 // bar.
1442 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1443 MC_Merge_SimpleBMHierarchy_DisjointSets_Under_BookmarkBar) {
1444 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1445 DisableVerifier();
1446
1447 for (int i = 0; i < 3; ++i) {
1448 std::wstring title = IndexedURLTitle(i+1);
1449 GURL url = GURL(IndexedURL(i+1));
1450 ASSERT_TRUE(AddURL(0, i, title, url) != NULL);
1451 }
1452
1453 for (int j = 0; j < 3; ++j) {
1454 std::wstring title = IndexedURLTitle(j+4);
1455 GURL url = GURL(IndexedURL(j+4));
1456 ASSERT_TRUE(AddURL(0, j, title, url) != NULL);
1457 }
1458
1459 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1460 ASSERT_TRUE(AwaitQuiescence());
1461 ASSERT_TRUE(AllModelsMatch());
1462 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1463 }
1464
1465 // TCM ID - 3616282 - Merge sets of duplicate bookmarks under bookmark bar.
1466 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1467 MC_Merge_SimpleBMHierarchy_DuplicateBMs_Under_BMBar) {
1468 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1469 DisableVerifier();
1470
1471 // Let's add duplicate set of bookmark {1,2,2,3,3,3,4,4,4,4} to client0.
1472 int node_index = 0;
1473 for (int i = 1; i < 5 ; ++i) {
1474 for (int j = 0; j < i; ++j) {
1475 std::wstring title = IndexedURLTitle(i);
1476 GURL url = GURL(IndexedURL(i));
1477 ASSERT_TRUE(AddURL(0, node_index, title, url) != NULL);
1478 ++node_index;
1479 }
1480 }
1481 // Let's add a set of bookmarks {1,2,3,4} to client1.
1482 for (int i = 0; i < 4; ++i) {
1483 std::wstring title = IndexedURLTitle(i+1);
1484 GURL url = GURL(IndexedURL(i+1));
1485 ASSERT_TRUE(AddURL(1, i, title, url) != NULL);
1486 }
1487
1488 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1489 ASSERT_TRUE(AwaitQuiescence());
1490 ASSERT_TRUE(AllModelsMatch());
1491
1492 for (int i = 1; i < 5 ; ++i) {
1493 ASSERT_TRUE(CountBookmarksWithTitlesMatching(1, IndexedURLTitle(i)) == i);
1494 }
1495 }
1496
1497 // TCM ID - 6593872.
1498 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, DisableBookmarks) {
1499 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1500 ASSERT_TRUE(AllModelsMatchVerifier());
1501
1502 ASSERT_TRUE(GetClient(1)->DisableSyncForDatatype(syncable::BOOKMARKS));
1503 ASSERT_TRUE(AddFolder(1, kGenericFolderName) != NULL);
1504 ASSERT_TRUE(AwaitQuiescence());
1505 ASSERT_FALSE(AllModelsMatch());
1506
1507 ASSERT_TRUE(GetClient(1)->EnableSyncForDatatype(syncable::BOOKMARKS));
1508 ASSERT_TRUE(AwaitQuiescence());
1509 ASSERT_TRUE(AllModelsMatch());
1510 }
1511
1512 // TCM ID - 7343544.
1513 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, DisableSync) {
1514 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1515 ASSERT_TRUE(AllModelsMatchVerifier());
1516
1517 ASSERT_TRUE(GetClient(1)->DisableSyncForAllDatatypes());
1518 ASSERT_TRUE(AddFolder(0, IndexedFolderName(0)) != NULL);
1519 ASSERT_TRUE(GetClient(0)->AwaitSyncCycleCompletion("Added a folder."));
1520 ASSERT_FALSE(AllModelsMatch());
1521
1522 ASSERT_TRUE(AddFolder(1, IndexedFolderName(1)) != NULL);
1523 ASSERT_FALSE(AllModelsMatch());
1524
1525 ASSERT_TRUE(GetClient(1)->EnableSyncForAllDatatypes());
1526 ASSERT_TRUE(AwaitQuiescence());
1527 ASSERT_TRUE(AllModelsMatch());
1528 }
1529
1530 // TCM ID - 3662298 - Test adding duplicate folder - Both with different BMs
1531 // underneath.
1532 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest, MC_DuplicateFolders) {
1533 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1534 DisableVerifier();
1535
1536 const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1537 ASSERT_TRUE(folder0 != NULL);
1538 const BookmarkNode* folder1 = AddFolder(1, kGenericFolderName);
1539 ASSERT_TRUE(folder1 != NULL);
1540 for (int i = 0; i < 5; ++i) {
1541 std::wstring title0 = IndexedURLTitle(i);
1542 GURL url0 = GURL(IndexedURL(i));
1543 ASSERT_TRUE(AddURL(0, folder0, i, title0, url0) != NULL);
1544 std::wstring title1 = IndexedURLTitle(i+5);
1545 GURL url1 = GURL(IndexedURL(i+5));
1546 ASSERT_TRUE(AddURL(1, folder1, i, title1, url1) != NULL);
1547 }
1548
1549 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1550 ASSERT_TRUE(AwaitQuiescence());
1551 ASSERT_TRUE(AllModelsMatch());
1552 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1553 }
1554
1555 // TCM ID - 3719307 - Test a scenario of updating the name of the same bookmark
1556 // from two clients at the same time.
1557 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1558 MC_BookmarkNameChangeConflict) {
1559 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1560
1561 const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1562 ASSERT_TRUE(folder0 != NULL);
1563 for (int i = 0; i < 3; ++i) {
1564 std::wstring title = IndexedURLTitle(i);
1565 GURL url = GURL(IndexedURL(i));
1566 ASSERT_TRUE(AddURL(0, folder0, i, title, url) != NULL);
1567 }
1568 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1569 ASSERT_TRUE(AllModelsMatchVerifier());
1570 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1571
1572 DisableVerifier();
1573 GURL url(IndexedURL(0));
1574 SetTitle(0, GetUniqueNodeByURL(0, url), L"Title++");
1575 SetTitle(1, GetUniqueNodeByURL(1, url), L"Title--");
1576
1577 ASSERT_TRUE(AwaitQuiescence());
1578 ASSERT_TRUE(AllModelsMatch());
1579 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1580 }
1581
1582 // TCM ID - 3672299 - Test a scenario of updating the URL of the same bookmark
1583 // from two clients at the same time.
1584 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1585 MC_BookmarkURLChangeConflict) {
1586 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1587
1588 const BookmarkNode* folder0 = AddFolder(0, kGenericFolderName);
1589 ASSERT_TRUE(folder0 != NULL);
1590 for (int i = 0; i < 3; ++i) {
1591 std::wstring title = IndexedURLTitle(i);
1592 GURL url = GURL(IndexedURL(i));
1593 ASSERT_TRUE(AddURL(0, folder0, i, title, url) != NULL);
1594 }
1595 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1596 ASSERT_TRUE(AllModelsMatchVerifier());
1597 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1598
1599 DisableVerifier();
1600 GURL url(IndexedURL(0));
1601 ASSERT_TRUE(SetURL(
1602 0, GetUniqueNodeByURL(0, url), GURL("http://www.google.com/00")));
1603 ASSERT_TRUE(SetURL(
1604 1, GetUniqueNodeByURL(1, url), GURL("http://www.google.com/11")));
1605
1606 ASSERT_TRUE(AwaitQuiescence());
1607 ASSERT_TRUE(AllModelsMatch());
1608 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1609 }
1610
1611 // TCM ID - 3699290 - Test a scenario of updating the BM Folder name from two
1612 // clients at the same time.
1613 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1614 MC_FolderNameChangeConflict) {
1615 ASSERT_TRUE(SetupClients()) << "SetupClients() failed.";
1616 DisableVerifier();
1617
1618 const BookmarkNode* folderA[2];
1619 const BookmarkNode* folderB[2];
1620 const BookmarkNode* folderC[2];
1621
1622 // Create empty folder A on both clients.
1623 folderA[0] = AddFolder(0, IndexedFolderName(0));
1624 ASSERT_TRUE(folderA[0] != NULL);
1625 folderA[1] = AddFolder(1, IndexedFolderName(0));
1626 ASSERT_TRUE(folderA[1] != NULL);
1627
1628 // Create folder B with bookmarks on both clients.
1629 folderB[0] = AddFolder(0, IndexedFolderName(1));
1630 ASSERT_TRUE(folderB[0] != NULL);
1631 folderB[1] = AddFolder(1, IndexedFolderName(1));
1632 ASSERT_TRUE(folderB[1] != NULL);
1633 for (int i = 0; i < 3; ++i) {
1634 std::wstring title = IndexedURLTitle(i);
1635 GURL url = GURL(IndexedURL(i));
1636 ASSERT_TRUE(AddURL(0, folderB[0], i, title, url) != NULL);
1637 }
1638
1639 // Create folder C with bookmarks and subfolders on both clients.
1640 folderC[0] = AddFolder(0, IndexedFolderName(2));
1641 ASSERT_TRUE(folderC[0] != NULL);
1642 folderC[1] = AddFolder(1, IndexedFolderName(2));
1643 ASSERT_TRUE(folderC[1] != NULL);
1644 for (int i = 0; i < 3; ++i) {
1645 std::wstring folder_name = IndexedSubfolderName(i);
1646 const BookmarkNode* subfolder = AddFolder(0, folderC[0], i, folder_name);
1647 ASSERT_TRUE(subfolder != NULL);
1648 for (int j = 0; j < 3; ++j) {
1649 std::wstring title = IndexedURLTitle(j);
1650 GURL url = GURL(IndexedURL(j));
1651 ASSERT_TRUE(AddURL(0, subfolder, j, title, url) != NULL);
1652 }
1653 }
1654
1655 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1656 ASSERT_TRUE(AwaitQuiescence());
1657 ASSERT_TRUE(AllModelsMatch());
1658 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1659
1660 // Simultaneously rename folder A on both clients.
1661 SetTitle(0, folderA[0], L"Folder A++");
1662 SetTitle(1, folderA[1], L"Folder A--");
1663 ASSERT_TRUE(AwaitQuiescence());
1664 ASSERT_TRUE(AllModelsMatch());
1665 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1666
1667 // Simultaneously rename folder B on both clients.
1668 SetTitle(0, folderB[0], L"Folder B++");
1669 SetTitle(1, folderB[1], L"Folder B--");
1670 ASSERT_TRUE(AwaitQuiescence());
1671 ASSERT_TRUE(AllModelsMatch());
1672 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1673
1674 // Simultaneously rename folder C on both clients.
1675 SetTitle(0, folderC[0], L"Folder C++");
1676 SetTitle(1, folderC[1], L"Folder C--");
1677 ASSERT_TRUE(AwaitQuiescence());
1678 ASSERT_TRUE(AllModelsMatch());
1679 ASSERT_FALSE(ContainsDuplicateBookmarks(0));
1680 }
1681
1682 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1683 SingleClientEnabledEncryption) {
1684 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1685 ASSERT_TRUE(AllModelsMatchVerifier());
1686
1687 ASSERT_TRUE(EnableEncryption(0, syncable::BOOKMARKS));
1688 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1689 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1690 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1691 ASSERT_TRUE(AllModelsMatchVerifier());
1692 }
1693
1694 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1695 SingleClientEnabledEncryptionAndChanged) {
1696 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1697 ASSERT_TRUE(AllModelsMatchVerifier());
1698
1699 ASSERT_TRUE(EnableEncryption(0, syncable::BOOKMARKS));
1700 ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1701 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1702 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1703 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1704 ASSERT_TRUE(AllModelsMatchVerifier());
1705 }
1706
1707 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1708 BothClientsEnabledEncryption) {
1709 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1710 ASSERT_TRUE(AllModelsMatchVerifier());
1711
1712 ASSERT_TRUE(EnableEncryption(0, syncable::BOOKMARKS));
1713 ASSERT_TRUE(EnableEncryption(1, syncable::BOOKMARKS));
1714 ASSERT_TRUE(AwaitQuiescence());
1715 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1716 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1717 ASSERT_TRUE(AllModelsMatchVerifier());
1718 }
1719
1720 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1721 SingleClientEnabledEncryptionBothChanged) {
1722 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1723 ASSERT_TRUE(AllModelsMatchVerifier());
1724
1725 ASSERT_TRUE(EnableEncryption(0, syncable::BOOKMARKS));
1726 ASSERT_TRUE(AwaitQuiescence());
1727 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1728 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1729 ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1730 ASSERT_TRUE(AddURL(0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1731 ASSERT_TRUE(AwaitQuiescence());
1732 ASSERT_TRUE(AllModelsMatchVerifier());
1733 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1734 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1735 }
1736
1737 IN_PROC_BROWSER_TEST_F(TwoClientBookmarksSyncTest,
1738 SingleClientEnabledEncryptionAndChangedMultipleTimes) {
1739 ASSERT_TRUE(SetupSync()) << "SetupSync() failed.";
1740 ASSERT_TRUE(AllModelsMatchVerifier());
1741
1742 ASSERT_TRUE(AddURL(0, IndexedURLTitle(0), GURL(IndexedURL(0))) != NULL);
1743 ASSERT_TRUE(EnableEncryption(0, syncable::BOOKMARKS));
1744 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1745 ASSERT_TRUE(IsEncrypted(0, syncable::BOOKMARKS));
1746 ASSERT_TRUE(IsEncrypted(1, syncable::BOOKMARKS));
1747 ASSERT_TRUE(AllModelsMatchVerifier());
1748
1749 ASSERT_TRUE(AddURL(0, IndexedURLTitle(1), GURL(IndexedURL(1))) != NULL);
1750 ASSERT_TRUE(AddFolder(0, IndexedFolderName(0)) != NULL);
1751 ASSERT_TRUE(GetClient(0)->AwaitMutualSyncCycleCompletion(GetClient(1)));
1752 ASSERT_TRUE(AllModelsMatchVerifier());
1753 }
1754
1755 // TODO(zea): Add first time sync functionality testing. In particular, when
1756 // there are encrypted types in first time sync we need to ensure we don't
1757 // duplicate bookmarks.
OLDNEW
« no previous file with comments | « chrome/test/live_sync/two_client_autofill_sync_test.cc ('k') | chrome/test/live_sync/two_client_extensions_sync_test.cc » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698