Removing useless Win7 checks + standardize its use

chrome/utility/importer/edge_database_reader_unittest_win.cc

 // Copyright 2015 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 "chrome/utility/importer/edge_database_reader_win.h"
 
 #include <windows.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <string.h>
 
 #include "base/files/file_util.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/win/windows_version.h"
 #include "chrome/common/chrome_paths.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/zlib/google/compression_utils.h"
 
 namespace {
 
 class EdgeDatabaseReaderTest : public ::testing::Test {
  protected:
   bool CopyTestDatabase(const base::string16& database_name,
                         base::FilePath* copied_path) {
@@ skipping 35 matching lines @@
            0;
   }
 
   base::ScopedTempDir temp_dir_;
   base::FilePath test_data_path_;
 };
 
 }  // namespace
 
 TEST_F(EdgeDatabaseReaderTest, OpenFileTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
 }
 
 TEST_F(EdgeDatabaseReaderTest, NoFileTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   EdgeDatabaseReader reader;
   EXPECT_FALSE(reader.OpenDatabase(L"ThisIsntARealFileName.edb"));
 }
 
 TEST_F(EdgeDatabaseReaderTest, RandomGarbageDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"random.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
 }
 
 TEST_F(EdgeDatabaseReaderTest, ZerosDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   std::string zeros(0x10000, '\0');
   ASSERT_TRUE(WriteFile(L"zeros.edb", zeros, &database_path));
   EdgeDatabaseReader reader;
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
 }
 
 TEST_F(EdgeDatabaseReaderTest, EmptyDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(WriteFile(L"empty.edb", "", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
 }
 
 TEST_F(EdgeDatabaseReaderTest, OpenTableDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidTableDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NotARealTableName");
   EXPECT_EQ(nullptr, table_enum);
 }
 
 TEST_F(EdgeDatabaseReaderTest, NotOpenDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   EdgeDatabaseReader reader;
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_EQ(nullptr, table_enum);
   EXPECT_EQ(JET_errDatabaseNotFound, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, AlreadyOpenDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   EXPECT_FALSE(reader.OpenDatabase(database_path.value()));
   EXPECT_EQ(JET_errOneDatabasePerSession, reader.last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, OpenTableAndReadDataDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     int32_t int_col_value = 0;
@@ skipping 39 matching lines @@
     bool bool_col_value;
     EXPECT_TRUE(table_enum->RetrieveColumn(L"BoolCol", &bool_col_value));
     EXPECT_EQ((row_count % 2) == 0, bool_col_value);
 
     row_count++;
   } while (table_enum->Next());
   EXPECT_EQ(16, row_count);
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckEnumResetDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int row_count = 0;
   do {
     row_count++;
   } while (table_enum->Next());
   EXPECT_NE(0, row_count);
   EXPECT_TRUE(table_enum->Reset());
   do {
     row_count--;
   } while (table_enum->Next());
   EXPECT_EQ(0, row_count);
 }
 
 TEST_F(EdgeDatabaseReaderTest, InvalidColumnDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"NotARealNameCol", &int_col_value));
   EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, NoColumnDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NoColsTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
   EXPECT_EQ(JET_errColumnNotFound, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, EmptyTableDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"EmptyTable");
   EXPECT_NE(nullptr, table_enum);
   int32_t int_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &int_col_value));
   EXPECT_NE(JET_errColumnNotFound, table_enum->last_error());
   EXPECT_FALSE(table_enum->Reset());
   EXPECT_FALSE(table_enum->Next());
 }
 
 TEST_F(EdgeDatabaseReaderTest, UnicodeStringsDatabaseTest) {
   const char* utf8_strings[] = {
       "\xE3\x81\x93\xE3\x81\xAB\xE3\x81\xA1\xE3\x81\xAF",
       "\xE4\xBD\xA0\xE5\xA5\xBD",
       "\xD0\x97\xD0\xB4\xD1\x80\xD0\xB0\xD0\xB2\xD1\x81\xD1\x82\xD0\xB2\xD1\x83"
       "\xD0\xB9\xD1\x82\xD0\xB5",
       "\x48\x65\x6C\x6C\x6F",
       "\xEC\x95\x88\xEB\x85\x95\xED\x95\x98\xEC\x84\xB8\xEC\x9A\x94",
   };
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
 
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"UnicodeTable");
   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(row_string, str_col_value);
     if (row_count < utf8_strings_count - 1)
       EXPECT_TRUE(table_enum->Next());
     else
       EXPECT_FALSE(table_enum->Next());
   }
 }
 
 TEST_F(EdgeDatabaseReaderTest, NonUnicodeStringsDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NonUnicodeTable");
   EXPECT_NE(nullptr, table_enum);
   base::string16 str_col_value;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckNullColumnDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"NullTable");
   EXPECT_NE(nullptr, table_enum);
 
   // We expect to successfully open a column value but get the default value
   // back.
@@ skipping 27 matching lines @@
   base::string16 str_col_value;
   EXPECT_TRUE(table_enum->RetrieveColumn(L"StrCol", &str_col_value));
   EXPECT_TRUE(str_col_value.empty());
 
   bool bool_col_value;
   EXPECT_TRUE(table_enum->RetrieveColumn(L"BoolCol", &bool_col_value));
   EXPECT_EQ(false, bool_col_value);
 }
 
 TEST_F(EdgeDatabaseReaderTest, CheckInvalidColumnTypeDatabaseTest) {
-  // Only verified to work with ESE library on Windows 7 and above.
-  if (base::win::GetVersion() < base::win::VERSION_WIN7)
-    return;
-
   base::FilePath database_path;
   ASSERT_TRUE(CopyTestDatabase(L"testdata.edb", &database_path));
   EdgeDatabaseReader reader;
   EXPECT_TRUE(reader.OpenDatabase(database_path.value()));
   std::unique_ptr<EdgeDatabaseTableEnumerator> table_enum =
       reader.OpenTableEnumerator(L"TestTable");
   EXPECT_NE(nullptr, table_enum);
 
   uint32_t uint_col_value = 0;
   EXPECT_FALSE(table_enum->RetrieveColumn(L"IntCol", &uint_col_value));
   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(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"LongLongCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"GuidCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"DateCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"StrCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
   EXPECT_FALSE(table_enum->RetrieveColumn(L"BoolCol", &uint_col_value));
   EXPECT_EQ(JET_errInvalidColumnType, table_enum->last_error());
 }