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"
+#include "env_chromium_stdio.h"
+#if defined(OS_WIN)
+#include "env_chromium_win.h"
+#endif
 #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 =
+      MakeIOErrorWin("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 {
+template <typename T>
+class MyEnv : public T {
  public:
   MyEnv() : directory_syncs_(0) {}
   int directory_syncs() { 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<ChromiumEnvStdio, ChromiumEnvWin> ChromiumEnvMultiPlatformTestsTypes;
+#else
+typedef ::testing::Types<ChromiumEnvStdio> ChromiumEnvMultiPlatformTestsTypes;
+#endif
+TYPED_TEST_CASE(ChromiumEnvMultiPlatformTests, ChromiumEnvMultiPlatformTestsTypes);
+
+TYPED_TEST(ChromiumEnvMultiPlatformTests, DirectorySyncing) {

[dgrogan, 2014/01/07 01:38:41]

Why not do the rest of the tests in this file as TYPED_TESTs?

[cmumford, 2014/01/07 18:43:38]

Not strictly necessary as this was the only explicit use of ChromiumEnv.
However, as you know, either ChromiumEnvStdio or ChromiumEnvWin will be
instantiated behind the scenes by IDB::Env(), and the remaining tests will only
test the default one. My plans for running these tests on both platforms was to
have command-line switches, and to have the tests run twice (once for each
platform).

We discussed this and felt it was too much effort for the benefit as Windows
will always test the Win32 API, and the other platforms will test Stdio.

+  MyEnv<TypeParam> env;
+
   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);
@@ skipping 124 matching lines @@
   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(); }