[Sync] Replaced ASSERT/EXPECT_TRUE/FALSE with expected/actual checks.

components/sync/syncable/directory_unittest.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "components/sync/syncable/directory_unittest.h"
 
 #include <stddef.h>
 
 #include <cstdlib>
 
@@ skipping 206 matching lines @@
 void SyncableDirectoryTest::ValidateEntry(BaseTransaction* trans,
                                           int64_t id,
                                           bool check_name,
                                           const std::string& name,
                                           int64_t base_version,
                                           int64_t server_version,
                                           bool is_del) {
   Entry e(trans, GET_BY_ID, TestIdFactory::FromNumber(id));
   ASSERT_TRUE(e.good());
   if (check_name)
-    ASSERT_TRUE(name == e.GetNonUniqueName());
-  ASSERT_TRUE(base_version == e.GetBaseVersion());
-  ASSERT_TRUE(server_version == e.GetServerVersion());
-  ASSERT_TRUE(is_del == e.GetIsDel());
+    ASSERT_EQ(name, e.GetNonUniqueName());
+  ASSERT_EQ(base_version, e.GetBaseVersion());
+  ASSERT_EQ(server_version, e.GetServerVersion());
+  ASSERT_EQ(is_del, e.GetIsDel());
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsMetahandlesToPurge) {
   const int metas_to_create = 50;
   MetahandleSet expected_purges;
   MetahandleSet all_handles;
   {
     dir()->SetDownloadProgress(BOOKMARKS, BuildProgress(BOOKMARKS));
     dir()->SetDownloadProgress(PREFERENCES, BuildProgress(PREFERENCES));
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
@@ skipping 13 matching lines @@
       e.PutServerSpecifics(specs);
     }
   }
 
   ModelTypeSet to_purge(BOOKMARKS);
   dir()->PurgeEntriesWithTypeIn(to_purge, ModelTypeSet(), ModelTypeSet());
 
   Directory::SaveChangesSnapshot snapshot1;
   base::AutoLock scoped_lock(dir()->kernel()->save_changes_mutex);
   dir()->TakeSnapshotForSaveChanges(&snapshot1);
-  EXPECT_TRUE(expected_purges == snapshot1.metahandles_to_purge);
+  EXPECT_EQ(expected_purges, snapshot1.metahandles_to_purge);
 
   to_purge.Clear();
   to_purge.Put(PREFERENCES);
   dir()->PurgeEntriesWithTypeIn(to_purge, ModelTypeSet(), ModelTypeSet());
 
   dir()->HandleSaveChangesFailure(snapshot1);
 
   Directory::SaveChangesSnapshot snapshot2;
   dir()->TakeSnapshotForSaveChanges(&snapshot2);
-  EXPECT_TRUE(all_handles == snapshot2.metahandles_to_purge);
+  EXPECT_EQ(all_handles, snapshot2.metahandles_to_purge);
 }
 
 TEST_F(SyncableDirectoryTest, TakeSnapshotGetsAllDirtyHandlesTest) {
   const int metahandles_to_create = 100;
   std::vector<int64_t> expected_dirty_metahandles;
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     for (int i = 0; i < metahandles_to_create; i++) {
       MutableEntry e(&trans, CREATE, BOOKMARKS, trans.root_id(), "foo");
       expected_dirty_metahandles.push_back(e.GetMetahandle());
@@ skipping 435 matching lines @@
 
     MutableEntry e3(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e3.good());
     e3.PutIsUnsynced(true);
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_EQ(1u, handles.size());
-    ASSERT_TRUE(handle1 == handles[0]);
+    ASSERT_EQ(handle1, handles[0]);
 
     MutableEntry e4(&trans, GET_BY_HANDLE, handle2);
     ASSERT_TRUE(e4.good());
     e4.PutIsUnsynced(true);
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_EQ(2u, handles.size());
     if (handle1 == handles[0]) {
-      ASSERT_TRUE(handle2 == handles[1]);
+      ASSERT_EQ(handle2, handles[1]);
     } else {
-      ASSERT_TRUE(handle2 == handles[0]);
-      ASSERT_TRUE(handle1 == handles[1]);
+      ASSERT_EQ(handle2, handles[0]);
+      ASSERT_EQ(handle1, handles[1]);
     }
 
     MutableEntry e5(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e5.good());
     ASSERT_TRUE(e5.GetIsUnsynced());
     ASSERT_TRUE(e5.PutIsUnsynced(false));
     ASSERT_FALSE(e5.GetIsUnsynced());
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnsyncedMetaHandles(&trans, &handles);
     ASSERT_EQ(1u, handles.size());
-    ASSERT_TRUE(handle2 == handles[0]);
+    ASSERT_EQ(handle2, handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestGetUnappliedUpdates) {
   std::vector<int64_t> handles;
   int64_t handle1, handle2;
   const FullModelTypeSet all_types = FullModelTypeSet::All();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
 
@@ skipping 24 matching lines @@
 
     MutableEntry e3(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e3.good());
     e3.PutIsUnappliedUpdate(true);
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_EQ(1u, handles.size());
-    ASSERT_TRUE(handle1 == handles[0]);
+    ASSERT_EQ(handle1, handles[0]);
 
     MutableEntry e4(&trans, GET_BY_HANDLE, handle2);
     ASSERT_TRUE(e4.good());
     e4.PutIsUnappliedUpdate(true);
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_EQ(2u, handles.size());
     if (handle1 == handles[0]) {
-      ASSERT_TRUE(handle2 == handles[1]);
+      ASSERT_EQ(handle2, handles[1]);
     } else {
-      ASSERT_TRUE(handle2 == handles[0]);
-      ASSERT_TRUE(handle1 == handles[1]);
+      ASSERT_EQ(handle2, handles[0]);
+      ASSERT_EQ(handle1, handles[1]);
     }
 
     MutableEntry e5(&trans, GET_BY_HANDLE, handle1);
     ASSERT_TRUE(e5.good());
     e5.PutIsUnappliedUpdate(false);
   }
   dir()->SaveChanges();
   {
     WriteTransaction trans(FROM_HERE, UNITTEST, dir().get());
     dir()->GetUnappliedUpdateMetaHandles(&trans, all_types, &handles);
     ASSERT_EQ(1u, handles.size());
-    ASSERT_TRUE(handle2 == handles[0]);
+    ASSERT_EQ(handle2, handles[0]);
   }
 }
 
 TEST_F(SyncableDirectoryTest, DeleteBug_531383) {
   // Try to evoke a check failure...
   TestIdFactory id_factory;
   int64_t grandchild_handle;
   {
     WriteTransaction wtrans(FROM_HERE, UNITTEST, dir().get());
     MutableEntry parent(&wtrans, CREATE, BOOKMARKS, id_factory.root(), "Bob");
@@ skipping 103 matching lines @@
 
   // Make sure we can find the entry in the folder.
   {
     ReadTransaction trans(FROM_HERE, dir().get());
     EXPECT_EQ(0, CountEntriesWithName(&trans, trans.root_id(), entry_name));
     EXPECT_EQ(1, CountEntriesWithName(&trans, folder_id, entry_name));
 
     Entry entry(&trans, GET_BY_ID, entry_id);
     ASSERT_TRUE(entry.good());
     EXPECT_EQ(entry_handle, entry.GetMetahandle());
-    EXPECT_TRUE(entry.GetNonUniqueName() == entry_name);
-    EXPECT_TRUE(entry.GetParentId() == folder_id);
+    EXPECT_EQ(entry_name, entry.GetNonUniqueName());
+    EXPECT_EQ(folder_id, entry.GetParentId());
   }
 }
 
 TEST_F(SyncableDirectoryTest, TestParentIdIndexUpdate) {
   std::string child_name = "child";
 
   WriteTransaction wt(FROM_HERE, UNITTEST, dir().get());
   MutableEntry parent_folder(&wt, CREATE, BOOKMARKS, wt.root_id(), "folder1");
   parent_folder.PutIsUnsynced(true);
   parent_folder.PutIsDir(true);
@@ skipping 1171 matching lines @@
 
   const base::DictionaryValue* first_result;
   ASSERT_TRUE(nodes->GetDictionary(0, &first_result));
   EXPECT_TRUE(first_result->HasKey("ID"));
   EXPECT_TRUE(first_result->HasKey("NON_UNIQUE_NAME"));
 }
 
 }  // namespace syncable
 
 }  // namespace syncer