Unrevert r245135 "Created new Windows LevelDB environment."

third_party/leveldatabase/env_chromium_unittest.cc

 // Copyright (c) 2013 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 "base/file_util.h"
 #include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/test/test_suite.h"
-#include "env_chromium.h"
+#if defined(OS_WIN)
+#include "env_chromium_win32.h"
+#endif
+#include "env_chromium_posix.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/leveldatabase/env_idb.h"
 #include "third_party/leveldatabase/src/include/leveldb/db.h"
 
 using namespace leveldb_env;
 using namespace leveldb;
 
 #define FPL FILE_PATH_LITERAL
 
 TEST(ErrorEncoding, OnlyAMethod) {
@@ skipping 26 matching lines @@
   const Status s =
       MakeIOError("Somefile.txt", "message", in_method, some_errno);
   MethodID method;
   int error;
   EXPECT_EQ(METHOD_AND_ERRNO,
             ParseMethodAndError(s.ToString().c_str(), &method, &error));
   EXPECT_EQ(in_method, method);
   EXPECT_EQ(some_errno, error);
 }
 
+#if defined(OS_WIN)
+TEST(ErrorEncoding, ErrnoWin32) {
+  const MethodID in_method = kWritableFileFlush;
+  const DWORD some_errno = ERROR_FILE_NOT_FOUND;
+  const Status s =
+      MakeIOErrorWin32("Somefile.txt", "message", in_method, some_errno);
+  MethodID method;
+  int error;
+  EXPECT_EQ(METHOD_AND_ERRNO,
+            ParseMethodAndError(s.ToString().c_str(), &method, &error));
+  EXPECT_EQ(in_method, method);
+  EXPECT_EQ(some_errno, error);
+}
+#endif
+
 TEST(ErrorEncoding, NoEncodedMessage) {
   Status s = Status::IOError("Some message", "from leveldb itself");
   MethodID method = kRandomAccessFileRead;
   int error = 4;
   EXPECT_EQ(NONE, ParseMethodAndError(s.ToString().c_str(), &method, &error));
   EXPECT_EQ(kRandomAccessFileRead, method);
   EXPECT_EQ(4, error);
 }
 
-class MyEnv : public ChromiumEnv {
+class MyEnvDelegate : public ChromiumEnvDelegate {
  public:
-  MyEnv() : directory_syncs_(0) {}
-  int directory_syncs() { return directory_syncs_; }
+  MyEnvDelegate() : directory_syncs_(0) {}
+  int directory_syncs() const { return directory_syncs_; }
 
- protected:
   virtual void DidSyncDir(const std::string& fname) {
     ++directory_syncs_;
-    ChromiumEnv::DidSyncDir(fname);
   }
 
  private:
   int directory_syncs_;
 };
 
-TEST(ChromiumEnv, DirectorySyncing) {
-  MyEnv env;
+template <typename T>
+class ChromiumEnvMultiPlatformTests : public ::testing::Test {
+ public:
+};
+
+#if defined(OS_WIN)
+typedef ::testing::Types<ChromiumEnvPosix, ChromiumEnvWin32> ChromiumEnvMultiPlatformTestsTypes;
+#else
+typedef ::testing::Types<ChromiumEnvPosix> ChromiumEnvMultiPlatformTestsTypes;
+#endif
+TYPED_TEST_CASE(ChromiumEnvMultiPlatformTests, ChromiumEnvMultiPlatformTestsTypes);
+
+TYPED_TEST(ChromiumEnvMultiPlatformTests, DirectorySyncing) {
+  TypeParam env;
+  MyEnvDelegate* delegate(new MyEnvDelegate());
+  env.SetDelegate(delegate);
+
   base::ScopedTempDir dir;
   dir.CreateUniqueTempDir();
   base::FilePath dir_path = dir.path();
   std::string some_data = "some data";
   Slice data = some_data;
 
   std::string manifest_file_name =
       FilePathToString(dir_path.Append(FILE_PATH_LITERAL("MANIFEST-001")));
   WritableFile* manifest_file_ptr;
   Status s = env.NewWritableFile(manifest_file_name, &manifest_file_ptr);
   EXPECT_TRUE(s.ok());
   scoped_ptr<WritableFile> manifest_file(manifest_file_ptr);
   manifest_file->Append(data);
-  EXPECT_EQ(0, env.directory_syncs());
+  EXPECT_EQ(0, delegate->directory_syncs());
   manifest_file->Append(data);
-  EXPECT_EQ(0, env.directory_syncs());
+  EXPECT_EQ(0, delegate->directory_syncs());
 
   std::string sst_file_name =
       FilePathToString(dir_path.Append(FILE_PATH_LITERAL("000003.sst")));
   WritableFile* sst_file_ptr;
   s = env.NewWritableFile(sst_file_name, &sst_file_ptr);
   EXPECT_TRUE(s.ok());
   scoped_ptr<WritableFile> sst_file(sst_file_ptr);
   sst_file->Append(data);
-  EXPECT_EQ(0, env.directory_syncs());
+  EXPECT_EQ(0, delegate->directory_syncs());
 
   manifest_file->Append(data);
-  EXPECT_EQ(1, env.directory_syncs());
+  EXPECT_EQ(1, delegate->directory_syncs());
   manifest_file->Append(data);
-  EXPECT_EQ(1, env.directory_syncs());
+  EXPECT_EQ(1, delegate->directory_syncs());
 }
 
 int CountFilesWithExtension(const base::FilePath& dir,
                             const base::FilePath::StringType& extension) {
   int matching_files = 0;
   base::FileEnumerator dir_reader(
       dir, false, base::FileEnumerator::FILES);
   for (base::FilePath fname = dir_reader.Next(); !fname.empty();
        fname = dir_reader.Next()) {
     if (fname.MatchesExtension(extension))
@@ skipping 93 matching lines @@
   leveldb::Status status = env->GetChildren(dir.AsUTF8Unsafe(), &result);
   EXPECT_TRUE(status.ok());
   EXPECT_EQ(1, result.size());
 
   // And a second time should also return one result
   status = env->GetChildren(dir.AsUTF8Unsafe(), &result);
   EXPECT_TRUE(status.ok());
   EXPECT_EQ(1, result.size());
 }
 
-int main(int argc, char** argv) { return base::TestSuite(argc, argv).Run(); }
+int main(int argc, char** argv) {
+  return base::TestSuite(argc, argv).Run();
+}