Noissue - fix typo "dowload" to "download" (n is absent)

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 115 matching lines @@
 
   class FilterEngineIsSubscriptionDownloadAllowedTest : public ::testing::Test
   {
   protected:
     typedef std::vector<std::pair<bool, std::string>> ConnectionTypes;
     DelayedWebRequest::SharedTasks webRequestTasks;
     DelayedTimer::SharedTasks timerTasks;
     FilterEngine::CreationParameters createParams;
     ConnectionTypes capturedConnectionTypes;
     bool isConnectionAllowed;
-    std::vector<std::function<void(bool)>> isSubscriptionDowloadAllowedCallbacks;
+    std::vector<std::function<void(bool)>> isSubscriptionDownloadAllowedCallbacks;
     FilterEnginePtr filterEngine;
     JsEnginePtr jsEngine;
 
     void SetUp()
     {
       isConnectionAllowed = true;
 
       JsEngineCreationParameters jsEngineParams;
       jsEngineParams.logSystem.reset(new LazyLogSystem());
       jsEngineParams.fileSystem.reset(new LazyFileSystem());
       jsEngineParams.timer = DelayedTimer::New(timerTasks);
       jsEngineParams.webRequest = DelayedWebRequest::New(webRequestTasks);
       jsEngine = CreateJsEngine(std::move(jsEngineParams));
 
       createParams.preconfiguredPrefs.emplace("first_run_subscription_auto_select", jsEngine->NewValue(false));
 
-      createParams.isSubscriptionDowloadAllowedCallback = [this](const std::string* allowedConnectionType,
-        const std::function<void(bool)>& isSubscriptionDowloadAllowedCallback){
+      createParams.isSubscriptionDownloadAllowedCallback = [this](const std::string* allowedConnectionType,
+        const std::function<void(bool)>& isSubscriptionDownloadAllowedCallback){
         capturedConnectionTypes.emplace_back(!!allowedConnectionType, allowedConnectionType ? *allowedConnectionType : std::string());
-        isSubscriptionDowloadAllowedCallbacks.emplace_back(isSubscriptionDowloadAllowedCallback);
+        isSubscriptionDownloadAllowedCallbacks.emplace_back(isSubscriptionDownloadAllowedCallback);
       };
     }
 
     Subscription EnsureExampleSubscriptionAndForceUpdate(const std::string& apppendToUrl = std::string())
     {
       auto subscriptionUrl = "http://example" + apppendToUrl;
       bool isSubscriptionDownloadStatusReceived = false;
       if (!filterEngine)
       {
         filterEngine = FilterEngine::Create(jsEngine, createParams);
         filterEngine->SetFilterChangeCallback([&isSubscriptionDownloadStatusReceived, &subscriptionUrl](const std::string& action, JsValue&& item)
         {
           if (action == "subscription.downloadStatus" && item.GetProperty("url").AsString() == subscriptionUrl)
             isSubscriptionDownloadStatusReceived = true;
         });
       }
       auto subscription = filterEngine->GetSubscription(subscriptionUrl);
       EXPECT_EQ(0u, subscription.GetProperty("filters").AsList().size()) << subscriptionUrl;
       EXPECT_TRUE(subscription.GetProperty("downloadStatus").IsNull()) << subscriptionUrl;
       subscription.UpdateFilters();
 
       // Since currently the check is called from implemenation of web request
       // they have to been firstly scheduled, namely before processing of
       // 'is subscription download allowed' callbacks;
       DelayedTimer::ProcessImmediateTimers(timerTasks);
 
-      for (const auto& isSubscriptionDowloadAllowedCallback : isSubscriptionDowloadAllowedCallbacks)
+      for (const auto& isSubscriptionDownloadAllowedCallback : isSubscriptionDownloadAllowedCallbacks)
       {
-        isSubscriptionDowloadAllowedCallback(isConnectionAllowed);
+        isSubscriptionDownloadAllowedCallback(isConnectionAllowed);
       }
-      isSubscriptionDowloadAllowedCallbacks.clear();
+      isSubscriptionDownloadAllowedCallbacks.clear();
 
       {
         auto ii_webRequest = std::find_if(webRequestTasks->begin(), webRequestTasks->end(), [&subscriptionUrl](const DelayedWebRequest::Task& task)->bool
         {
           return Utils::BeginsWith(task.url, subscriptionUrl);
         });
 
         // if download is allowed then there should be a web request
         EXPECT_EQ(isConnectionAllowed, ii_webRequest != webRequestTasks->end());
         if (ii_webRequest != webRequestTasks->end())
@@ skipping 733 matching lines @@
       ASSERT_TRUE(aaSubscription);
       aaSubscription->RemoveFromList();
     }
 
     testSubscriptionState(parameter.expectedAAStatus, otherSubscriptionsNumber);
   }
 }
 
 TEST_F(FilterEngineIsSubscriptionDownloadAllowedTest, AbsentCallbackAllowsUpdating)
 {
-  createParams.isSubscriptionDowloadAllowedCallback = FilterEngine::IsConnectionAllowedAsyncCallback();
+  createParams.isSubscriptionDownloadAllowedCallback = FilterEngine::IsConnectionAllowedAsyncCallback();
   auto subscription = EnsureExampleSubscriptionAndForceUpdate();
   EXPECT_EQ("synchronize_ok", subscription.GetProperty("downloadStatus").AsString());
   EXPECT_EQ(1u, subscription.GetProperty("filters").AsList().size());
 }
 
 TEST_F(FilterEngineIsSubscriptionDownloadAllowedTest, AllowingCallbackAllowsUpdating)
 {
   // no stored allowed_connection_type preference
   auto subscription = EnsureExampleSubscriptionAndForceUpdate();
   EXPECT_EQ("synchronize_ok", subscription.GetProperty("downloadStatus").AsString());
@@ skipping 58 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);
   }
 }