VariationsService now supports wildcard in min/max version

chrome/browser/metrics/variations_service_unittest.cc

 // Copyright (c) 2012 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 "chrome/browser/metrics/proto/study.pb.h"
 #include "chrome/browser/metrics/variations_service.h"
 #include "chrome/common/chrome_version_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
@@ skipping 112 matching lines @@
     const char* min_version;
     const char* version;
     bool expected_result;
   } min_test_cases[] = {
     { "1.2.2", "1.2.3", true },
     { "1.2.3", "1.2.3", true },
     { "1.2.4", "1.2.3", false },
     { "1.3.2", "1.2.3", false },
     { "2.1.2", "1.2.3", false },
     { "0.3.4", "1.2.3", true },
+    // Wildcards.
+    { "1.*", "1.2.3", true },
+    { "1.2.*", "1.2.3", true },
+    { "1.2.3.*", "1.2.3", true },
+    { "1.2.4.*", "1.2.3", false },
+    { "2.*", "1.2.3", false },
+    { "0.3.*", "1.2.3", true },
   };
 
   const struct {
     const char* max_version;
     const char* version;
     bool expected_result;
   } max_test_cases[] = {
     { "1.2.2", "1.2.3", false },
     { "1.2.3", "1.2.3", true },
     { "1.2.4", "1.2.3", true },
     { "2.1.1", "1.2.3", true },
     { "2.1.1", "2.3.4", false },
+    // Wildcards
+    { "2.1.*", "2.3.4", false },
+    { "2.*", "2.3.4", true },
+    { "2.3.*", "2.3.4", true },
+    { "2.3.4.*", "2.3.4", true },
+    { "2.3.4.0.*", "2.3.4", true },
+    { "2.4.*", "2.3.4", true },
+    { "1.3.*", "2.3.4", false },
+    { "1.*", "2.3.4", false },
   };
 
   chrome_variations::Study_Filter filter;
 
   // Min/max version not set should result in true.
   EXPECT_TRUE(VariationsService::CheckStudyVersion(filter, "1.2.3"));
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(min_test_cases); ++i) {
     filter.set_min_version(min_test_cases[i].min_version);
     const bool result =
         VariationsService::CheckStudyVersion(filter, min_test_cases[i].version);
     EXPECT_EQ(min_test_cases[i].expected_result, result) <<
-        "Case " << i << " failed!";
+        "Min. version case " << i << " failed!";
   }
   filter.clear_min_version();
 
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(max_test_cases); ++i) {
     filter.set_max_version(max_test_cases[i].max_version);
     const bool result =
         VariationsService::CheckStudyVersion(filter, max_test_cases[i].version);
     EXPECT_EQ(max_test_cases[i].expected_result, result) <<
-        "Case " << i << " failed!";
+        "Max version case " << i << " failed!";
   }
 
   // Check intersection semantics.
   for (size_t i = 0; i < ARRAYSIZE_UNSAFE(min_test_cases); ++i) {
     for (size_t j = 0; j < ARRAYSIZE_UNSAFE(max_test_cases); ++j) {
       filter.set_min_version(min_test_cases[i].min_version);
       filter.set_max_version(max_test_cases[j].max_version);
 
       if (!min_test_cases[i].expected_result) {
         const bool result =
             VariationsService::CheckStudyVersion(filter,
                                                  min_test_cases[i].version);
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
 
       if (!max_test_cases[j].expected_result) {
         const bool result =
             VariationsService::CheckStudyVersion(filter,
                                                  max_test_cases[j].version);
         EXPECT_FALSE(result) << "Case " << i << "," << j << " failed!";
       }
     }
   }
 }
 
-// The current client logic does not handle version number strings containing
-// wildcards. Check that any such values received from the server result in the
-// study being disqualified.
-TEST(VariationsServiceTest, CheckStudyVersionWildcards) {
-  chrome_variations::Study_Filter filter;
-
-  filter.set_min_version("1.0.*");
-  EXPECT_FALSE(VariationsService::CheckStudyVersion(filter, "1.2.3"));
-
-  filter.clear_min_version();
-  filter.set_max_version("2.0.*");
-  EXPECT_FALSE(VariationsService::CheckStudyVersion(filter, "1.2.3"));
-}
-
 TEST(VariationsServiceTest, CheckStudyStartDate) {
   const base::Time now = base::Time::Now();
   const base::TimeDelta delta = base::TimeDelta::FromHours(1);
   const struct {
     const base::Time start_date;
     bool expected_result;
   } start_test_cases[] = {
     { now - delta, true },
     { now, true },
     { now + delta, false },
@@ skipping 48 matching lines @@
   chrome_variations::Study_Experiment* default_group = study.add_experiment();
   default_group->set_name("def");
   default_group->set_probability_weight(200);
 
   base::FieldTrial::Probability total_probability = 0;
   bool valid = VariationsService::ValidateStudyAndComputeTotalProbability(
       study, &total_probability);
   EXPECT_TRUE(valid);
   EXPECT_EQ(300, total_probability);
 
+  // Min version checks.
+  study.mutable_filter()->set_min_version("1.2.3.*");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_TRUE(valid);
+  study.mutable_filter()->set_min_version("1.*.3");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_FALSE(valid);
+  study.mutable_filter()->set_min_version("1.2.3");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_TRUE(valid);
+
+  // Max version checks.
+  study.mutable_filter()->set_max_version("2.3.4.*");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_TRUE(valid);
+  study.mutable_filter()->set_max_version("*.3");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_FALSE(valid);
+  study.mutable_filter()->set_max_version("2.3.4");
+  valid = VariationsService::ValidateStudyAndComputeTotalProbability(
+      study, &total_probability);
+  EXPECT_TRUE(valid);
+
   study.clear_default_experiment_name();
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 
   study.set_default_experiment_name("xyz");
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 
   study.set_default_experiment_name("def");
   default_group->clear_name();
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 
   default_group->set_name("def");
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   ASSERT_TRUE(valid);
   chrome_variations::Study_Experiment* repeated_group = study.add_experiment();
   repeated_group->set_name("abc");
   repeated_group->set_probability_weight(1);
   valid = VariationsService::ValidateStudyAndComputeTotalProbability(study,
       &total_probability);
   EXPECT_FALSE(valid);
 }