Fixed test code to pass the correct order for EXPECT_EQ/NE macros.

This CL fixes the order of parameters being passed to the test macros as
well as a minor issue with a build file noted in a previous CL.

Review URL: https://codereview.chromium.org/1522253005

Cr-Commit-Position: refs/heads/master@{#365823}

1 files changed, 45 insertions, 45 deletions

diff --git a/chrome/utility/importer/edge_database_reader_unittest_win.cc b/chrome/utility/importer/edge_database_reader_unittest_win.cc
index c902bcb..c9bb321 100644
--- a/chrome/utility/importer/edge_database_reader_unittest_win.cc
+++ b/chrome/utility/importer/edge_database_reader_unittest_win.cc
@@ -132,7 +132,7 @@ TEST_F(EdgeDatabaseReaderTest, OpenTableDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidTableDatabaseTest) {
@@ -146,7 +146,7 @@ TEST_F(EdgeDatabaseReaderTest, InvalidTableDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NotARealTableName");
-  EXPECT_EQ(table_enum, nullptr);
+  EXPECT_EQ(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, NotOpenDatabaseTest) {
@@ -157,8 +157,8 @@ TEST_F(EdgeDatabaseReaderTest, NotOpenDatabaseTest) {
   EdgeDatabaseReader reader;
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_EQ(table_enum, nullptr);
-  EXPECT_EQ(reader.last_error(), JET_errDatabaseNotFound);
+  EXPECT_EQ(nullptr, table_enum);
+  EXPECT_EQ(JET_errDatabaseNotFound, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, AlreadyOpenDatabaseTest) {
@@ -171,7 +171,7 @@ TEST_F(EdgeDatabaseReaderTest, AlreadyOpenDatabaseTest) {
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
-  EXPECT_EQ(reader.last_error(), JET_errOneDatabasePerSession);
+  EXPECT_EQ(JET_errOneDatabasePerSession, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, OpenTableAndReadDataDatabaseTest) {
@@ -185,28 +185,28 @@ TEST_F(EdgeDatabaseReaderTest, OpenTableAndReadDataDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     int32_t int_col_value = 0;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
-    EXPECT_EQ(int_col_value, -row_count);
+    EXPECT_EQ(-row_count, int_col_value);
 
     uint32_t uint_col_value = 0;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"UIntCol", &uint_col_value));
-    EXPECT_EQ(uint_col_value, static_cast<uint32_t>(row_count));
+    EXPECT_EQ(static_cast<uint32_t>(row_count), uint_col_value);
 
     int64_t longlong_col_value = 0;
     EXPECT_TRUE(
         table_enum->RetrieveColumn(L"LongLongCol", &longlong_col_value));
-    EXPECT_EQ(longlong_col_value, row_count);
+    EXPECT_EQ(row_count, longlong_col_value);
 
     GUID guid_col_value = {};
     GUID expected_guid_col_value = {};
     EXPECT_TRUE(table_enum->RetrieveColumn(L"GuidCol", &guid_col_value));
     memset(&expected_guid_col_value, row_count,
            sizeof(expected_guid_col_value));
-    EXPECT_EQ(guid_col_value, expected_guid_col_value);
+    EXPECT_EQ(expected_guid_col_value, guid_col_value);
 
     FILETIME filetime_col_value = {};
     FILETIME expected_filetime_col_value = {};
@@ -218,23 +218,23 @@ TEST_F(EdgeDatabaseReaderTest, OpenTableAndReadDataDatabaseTest) {
     EXPECT_TRUE(
         SystemTimeToFileTime(&system_time, &expected_filetime_col_value));
     EXPECT_TRUE(table_enum->RetrieveColumn(L"DateCol", &filetime_col_value));
-    EXPECT_EQ(filetime_col_value.dwLowDateTime,
-              expected_filetime_col_value.dwLowDateTime);
-    EXPECT_EQ(filetime_col_value.dwHighDateTime,
-              expected_filetime_col_value.dwHighDateTime);
+    EXPECT_EQ(expected_filetime_col_value.dwLowDateTime,
+              filetime_col_value.dwLowDateTime);
+    EXPECT_EQ(expected_filetime_col_value.dwHighDateTime,
+              filetime_col_value.dwHighDateTime);
 
     std::wstring row_string = base::StringPrintf(L"String: %d", row_count);
     base::string16 str_col_value;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
-    EXPECT_EQ(str_col_value, row_string);
+    EXPECT_EQ(row_string, str_col_value);
 
     bool bool_col_value;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"BoolCol", &bool_col_value));
-    EXPECT_EQ(bool_col_value, (row_count % 2) == 0);
+    EXPECT_EQ((row_count % 2) == 0, bool_col_value);
 
     row_count++;
   } while (table_enum->Next());
-  EXPECT_EQ(row_count, 16);
+  EXPECT_EQ(16, row_count);
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckEnumResetDatabaseTest) {
@@ -248,17 +248,17 @@ TEST_F(EdgeDatabaseReaderTest, CheckEnumResetDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     row_count++;
   } while (table_enum->Next());
-  EXPECT_NE(row_count, 0);
+  EXPECT_NE(0, row_count);
   EXPECT_TRUE(table_enum->Reset());
   do {
     row_count--;
   } while (table_enum->Next());
-  EXPECT_EQ(row_count, 0);
+  EXPECT_EQ(0, row_count);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidColumnDatabaseTest) {
@@ -272,10 +272,10 @@ TEST_F(EdgeDatabaseReaderTest, InvalidColumnDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"NotARealNameCol", &int_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errColumnNotFound);
+  EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, NoColumnDatabaseTest) {
@@ -289,10 +289,10 @@ TEST_F(EdgeDatabaseReaderTest, NoColumnDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NoColsTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errColumnNotFound);
+  EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, EmptyTableDatabaseTest) {
@@ -306,10 +306,10 @@ TEST_F(EdgeDatabaseReaderTest, EmptyTableDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"EmptyTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
-  EXPECT_NE(table_enum->last_error(), JET_errColumnNotFound);
+  EXPECT_NE(JET_errColumnNotFound, table_enum->last_error());
   EXPECT_FALSE(table_enum->Reset());
   EXPECT_FALSE(table_enum->Next());
 }
@@ -333,13 +333,13 @@ TEST_F(EdgeDatabaseReaderTest, UnicodeStringsDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"UnicodeTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   size_t utf8_strings_count = arraysize(utf8_strings);
   for (size_t row_count = 0; row_count < utf8_strings_count; ++row_count) {
     std::wstring row_string = base::UTF8ToWide(utf8_strings[row_count]);
     base::string16 str_col_value;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
-    EXPECT_EQ(str_col_value, row_string);
+    EXPECT_EQ(row_string, str_col_value);
     if (row_count < utf8_strings_count - 1)
       EXPECT_TRUE(table_enum->Next());
     else
@@ -358,10 +358,10 @@ TEST_F(EdgeDatabaseReaderTest, NonUnicodeStringsDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NonUnicodeTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
   base::string16 str_col_value;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
@@ -375,7 +375,7 @@ TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NullTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
 
   // We expect to successfully open a column value but get the default value
   // back.
@@ -396,15 +396,15 @@ TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
   memset(&guid_col_value, 0x1, sizeof(guid_col_value));
   EXPECT_TRUE(table_enum->RetrieveColumn(L"GuidCol", &guid_col_value));
   memset(&expected_guid_col_value, 0, sizeof(expected_guid_col_value));
-  EXPECT_EQ(guid_col_value, expected_guid_col_value);
+  EXPECT_EQ(expected_guid_col_value, guid_col_value);
 
   FILETIME filetime_col_value = {1, 1};
   FILETIME expected_filetime_col_value = {};
   EXPECT_TRUE(table_enum->RetrieveColumn(L"DateCol", &filetime_col_value));
-  EXPECT_EQ(filetime_col_value.dwLowDateTime,
-            expected_filetime_col_value.dwLowDateTime);
-  EXPECT_EQ(filetime_col_value.dwHighDateTime,
-            expected_filetime_col_value.dwHighDateTime);
+  EXPECT_EQ(expected_filetime_col_value.dwLowDateTime,
+            filetime_col_value.dwLowDateTime);
+  EXPECT_EQ(expected_filetime_col_value.dwHighDateTime,
+            filetime_col_value.dwHighDateTime);
 
   base::string16 str_col_value;
   EXPECT_TRUE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
@@ -412,7 +412,7 @@ TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
 
   bool bool_col_value;
   EXPECT_TRUE(table_enum->RetrieveColumn(L"BoolCol", &bool_col_value));
-  EXPECT_EQ(bool_col_value, false);
+  EXPECT_EQ(false, bool_col_value);
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckInvalidColumnTypeDatabaseTest) {
@@ -426,23 +426,23 @@ TEST_F(EdgeDatabaseReaderTest, CheckInvalidColumnTypeDatabaseTest) {
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   scoped_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
-  EXPECT_NE(table_enum, nullptr);
+  EXPECT_NE(nullptr, table_enum);
 
   uint32_t uint_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   // Check unsigned int with a signed int.
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"UIntCol", &int_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"LongLongCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"GuidCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"DateCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"BoolCol", &uint_col_value));
-  EXPECT_EQ(table_enum->last_error(), JET_errInvalidColumnType);
+  EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }