Allow TranslateRanker to override decisions taken by heuristics.

components/translate/core/browser/translate_ranker_impl_unittest.cc

 // Copyright 2016 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 "components/translate/core/browser/translate_ranker_impl.h"
 
 #include <initializer_list>
 #include <memory>
 
 #include "base/feature_list.h"
@@ skipping 14 matching lines @@
 #include "components/translate/core/browser/translate_prefs.h"
 #include "net/url_request/test_url_fetcher_factory.h"
 #include "net/url_request/url_request_test_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 using translate::kTranslateRankerEnforcement;
 using translate::kTranslateRankerLogging;
 using translate::kTranslateRankerQuery;
+using translate::kTranslateRankerDecisionOverride;
 using translate::TranslateDownloadManager;
 using translate::TranslateRankerFeatures;
 using translate::TranslatePrefs;
 using translate::TranslateRankerImpl;
 
 class TranslateRankerImplTest : public ::testing::Test {
  protected:
   TranslateRankerImplTest();
 
   void SetUp() override;
@@ skipping 144 matching lines @@
   return translate_event;
 }
 
 }  // namespace
 
 TEST_F(TranslateRankerImplTest, DisabledByDefault) {
   InitFeatures({}, {});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_FALSE(ranker->IsQueryEnabled());
   EXPECT_FALSE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_FALSE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, ExplicitlyDisabled) {
   InitFeatures({}, {kTranslateRankerQuery, kTranslateRankerEnforcement,
-                    kTranslateRankerLogging});
+                    kTranslateRankerLogging, kTranslateRankerDecisionOverride});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_FALSE(ranker->IsQueryEnabled());
   EXPECT_FALSE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_FALSE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, EnableQuery) {
   InitFeatures({kTranslateRankerQuery}, {kTranslateRankerEnforcement});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_TRUE(ranker->IsQueryEnabled());
   EXPECT_FALSE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_FALSE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, EnableEnforcement) {
   InitFeatures({kTranslateRankerEnforcement}, {kTranslateRankerQuery});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_FALSE(ranker->IsQueryEnabled());
   EXPECT_TRUE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_FALSE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, EnableQueryAndEnforcement) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_TRUE(ranker->IsQueryEnabled());
   EXPECT_TRUE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_FALSE(ranker->IsLoggingEnabled());
 }
 
+TEST_F(TranslateRankerImplTest, EnableDecisionOverride) {
+  InitFeatures({kTranslateRankerDecisionOverride}, {});
+  auto ranker = GetRankerForTest(0.5);
+  EXPECT_FALSE(ranker->IsQueryEnabled());
+  EXPECT_TRUE(ranker->IsEnforcementEnabled());
+  EXPECT_TRUE(ranker->IsDecisionOverrideEnabled());
+  EXPECT_FALSE(ranker->IsLoggingEnabled());
+}
+
 TEST_F(TranslateRankerImplTest, EnableLogging) {
   InitFeatures({kTranslateRankerLogging}, {});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_FALSE(ranker->IsQueryEnabled());
   EXPECT_FALSE(ranker->IsEnforcementEnabled());
+  EXPECT_FALSE(ranker->IsDecisionOverrideEnabled());
   EXPECT_TRUE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, EnableAll) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement,
-                kTranslateRankerLogging},
+                kTranslateRankerLogging, kTranslateRankerDecisionOverride},
                {});
   auto ranker = GetRankerForTest(0.5);
   EXPECT_TRUE(ranker->IsQueryEnabled());
   EXPECT_TRUE(ranker->IsEnforcementEnabled());
+  EXPECT_TRUE(ranker->IsDecisionOverrideEnabled());
   EXPECT_TRUE(ranker->IsLoggingEnabled());
 }
 
 TEST_F(TranslateRankerImplTest, CalculateScore) {
   InitFeatures({kTranslateRankerQuery, kTranslateRankerEnforcement}, {});
   auto ranker = GetRankerForTest(0.01f);
   // Calculate the score using: a 50:50 accept/decline ratio; the one-hot
   // values for the src lang, dest lang, locale and counry; and, the bias.
   double expected = Sigmoid(50.0 * 0.13f +   // accept count * weight
                             50.0 * -0.14f +  // decline count * weight
@@ skipping 55 matching lines @@
   EXPECT_EQ(0U, flushed_events.size());
 
   ranker->AddTranslateEvent(CreateTranslateEvent("fr", "en", 1, 0, 3));
   ranker->AddTranslateEvent(CreateTranslateEvent("jp", "en", 2, 0, 3));
   ranker->AddTranslateEvent(CreateTranslateEvent("es", "de", 4, 5, 6));
 
   // Logging is disabled, so no events should be cached.
   ranker->FlushTranslateEvents(&flushed_events);
   EXPECT_EQ(0U, flushed_events.size());
 }