Issue 5183 - Provide async interface for FileSystem

test/FilterEngine.cpp

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2017 eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 59 matching lines @@
   typedef FilterEngineTestGeneric<VeryLazyFileSystem, LazyLogSystem> FilterEngineTestNoData;
 
   class FilterEngineWithFreshFolder : public ::testing::Test
   {
   protected:
     FileSystemPtr fileSystem;
     std::weak_ptr<JsEngine> weakJsEngine;
 
     void SetUp() override
     {
-      fileSystem.reset(new DefaultFileSystem());
+      fileSystem = CreateDefaultFileSystem();
       // Since there is neither in memory FS nor functionality to work with
       // directories use the hack: manually clean the directory.
       removeFileIfExists("patterns.ini");
       removeFileIfExists("prefs.json");
     }
     JsEnginePtr createJsEngine(const AppInfo& appInfo = AppInfo())
     {
       JsEngineCreationParameters jsEngineParams;
       jsEngineParams.appInfo = appInfo;
       jsEngineParams.fileSystem = fileSystem;
@@ skipping 11 matching lines @@
       fileSystem.reset();
     }
     void removeFileIfExists(const std::string& path)
     {
       // Hack: allow IO to finish currently running operations, in particular
       // writing into files. Otherwise we get "Permission denied".
       auto safeRemove = [this, &path]()->bool
       {
         try
         {
-          if (fileSystem->Stat(path).exists)
-            fileSystem->Remove(path);
-          return true;
+          Sync sync;
+          auto fs = fileSystem;
+          fileSystem->Stat(path,
+            [fs, &path, &sync](const IFileSystem::StatResult& stats, const std::string& error)
+            {
+              if (error.empty() && stats.exists)
+              {
+                fs->Remove(path, [&sync](const std::string& error)
+                  {
+                    sync.Set(error);
+                  });
+              }
+              else
+                sync.Set(error);
+            });
+          sync.Wait();
+          return sync.GetError().empty();
         }
         catch (...)
         {
           return false;
         }
       };
       int i = 5;
       while ((i-- > 0 && weakJsEngine.lock()) || !safeRemove())
         std::this_thread::sleep_for(std::chrono::seconds(2));
     }
@@ skipping 453 matching lines @@
 {
   int timesCalled = 0;
   std::this_thread::sleep_for(std::chrono::milliseconds(200));
   filterEngine->SetFilterChangeCallback([&timesCalled](const std::string&, AdblockPlus::JsValue&&)
   {
     timesCalled++;
   });
   filterEngine->GetFilter("foo").AddToList();
   EXPECT_EQ(1, timesCalled);
 
+  // we want to actually check the call count didn't change.
+  int previousTimesCalled = timesCalled;
   filterEngine->RemoveFilterChangeCallback();
   filterEngine->GetFilter("foo").RemoveFromList();
-  EXPECT_EQ(1, timesCalled);
+  EXPECT_EQ(previousTimesCalled, timesCalled);
 }
 
 TEST_F(FilterEngineTest, DocumentWhitelisting)
 {
   filterEngine->GetFilter("@@||example.org^$document").AddToList();
   filterEngine->GetFilter("@@||example.com^$document,domain=example.de").AddToList();
 
   ASSERT_TRUE(filterEngine->IsDocumentWhitelisted(
       "http://example.org",
       std::vector<std::string>()));
@@ skipping 409 matching lines @@
     std::string testConnection = "test connection";
     filterEngine->SetAllowedConnectionType(&testConnection);
     auto subscription = EnsureExampleSubscriptionAndForceUpdate("subB");
     EXPECT_EQ("synchronize_ok", subscription.GetProperty("downloadStatus").AsString());
     EXPECT_EQ(1u, subscription.GetProperty("filters").AsList().size());
     ASSERT_EQ(1u, capturedConnectionTypes.size());
     EXPECT_TRUE(capturedConnectionTypes[0].first);
     EXPECT_EQ(testConnection, capturedConnectionTypes[0].second);
   }
 }