Win 10 Inactive toast experiment metrics and storage modifications.

chrome/installer/util/experiment_unittest.cc

+// Copyright 2017 The Chromium Authors. All rights reserved.

[grt (UTC plus 2), 2017/06/09 20:02:27]

this set of tests is downright awesome!

[nikunjb, 2017/06/13 00:27:36]

Acknowledged. Thanks.

+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "chrome/installer/util/experiment.h"
+
+#include <cmath>
+
+#include "base/time/time.h"
+#include "chrome/installer/util/experiment_metrics.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace installer {
+
+TEST(ExperimentTest, TestInitializeFromMetrics) {
+  Experiment experiment;
+  ExperimentMetrics metrics_with_group;
+  metrics_with_group.state = ExperimentMetrics::kGroupAssigned;
+  metrics_with_group.group = 5;
+  experiment.InitializeFromMetrics(metrics_with_group);
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.state());
+  EXPECT_EQ(5, experiment.group());
+}
+
+TEST(ExperimentTest, TestSetState) {
+  Experiment experiment;
+  EXPECT_EQ(ExperimentMetrics::kUninitialized, experiment.state());
+  EXPECT_EQ(ExperimentMetrics::kUninitialized, experiment.metrics().state);
+  experiment.SetState(ExperimentMetrics::kGroupAssigned);
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.metrics().state);
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.state());
+}
+
+TEST(ExperimentTest, TestAssignGroup) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+  EXPECT_EQ(5, experiment.metrics().group);
+  EXPECT_EQ(5, experiment.group());
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.metrics().state);
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.state());
+}
+
+TEST(ExperimentTest, TestSetInactiveDays) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+
+  experiment.SetInactiveDays(0);
+  EXPECT_EQ(0, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(0, experiment.inactive_days());
+
+  experiment.SetInactiveDays(28);
+  EXPECT_EQ(57, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(28, experiment.inactive_days());
+
+  experiment.SetInactiveDays(35);
+  EXPECT_EQ(61, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(35, experiment.inactive_days());
+
+  experiment.SetInactiveDays(60);
+  EXPECT_EQ(70, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(60, experiment.inactive_days());
+
+  experiment.SetInactiveDays(ExperimentMetrics::kMaxLastUsed);
+  EXPECT_EQ(127, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(ExperimentMetrics::kMaxLastUsed, experiment.inactive_days());
+
+  experiment.SetInactiveDays(2 * ExperimentMetrics::kMaxLastUsed);
+  EXPECT_EQ(127, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(2 * ExperimentMetrics::kMaxLastUsed, experiment.inactive_days());
+}
+
+TEST(ExperimentTest, TestSetDisplayTime) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+  base::Time zero_day =
+      base::Time::FromDoubleT(ExperimentMetrics::kExperimentStartSeconds);
+  experiment.SetDisplayTime(zero_day);
+  EXPECT_EQ(0, experiment.metrics().first_toast_offset);
+  EXPECT_EQ(zero_day, experiment.first_display_time());
+  EXPECT_EQ(zero_day, experiment.latest_display_time());
+
+  base::Time one_day = zero_day + base::TimeDelta::FromDays(1);
+  experiment.SetDisplayTime(one_day);
+  EXPECT_EQ(1, experiment.metrics().first_toast_offset);
+  EXPECT_EQ(one_day, experiment.first_display_time());
+  EXPECT_EQ(one_day, experiment.latest_display_time());
+
+  // Test that calling SetDisplayTime again will not reset first_toast_offset.
+  base::Time two_day = zero_day + base::TimeDelta::FromDays(2);
+  experiment.SetDisplayTime(two_day);
+  EXPECT_EQ(1, experiment.metrics().first_toast_offset);
+  EXPECT_EQ(one_day, experiment.first_display_time());
+  EXPECT_EQ(two_day, experiment.latest_display_time());
+
+  // Test for maximum value.
+  Experiment new_experiment;
+  new_experiment.AssignGroup(5);
+  base::Time max_day = zero_day + base::TimeDelta::FromDays(
+                                      ExperimentMetrics::kMaxFirstToastOffset);
+  new_experiment.SetDisplayTime(max_day);
+  EXPECT_EQ(ExperimentMetrics::kMaxFirstToastOffset,
+            new_experiment.metrics().first_toast_offset);
+  EXPECT_EQ(max_day, new_experiment.first_display_time());
+  EXPECT_EQ(max_day, new_experiment.latest_display_time());
+
+  // Test setting toast_hour. Since it depends on local time it is
+  // tested by setting toast hour for two consecutive hours and verifying the
+  // difference is 1.
+  base::Time two_day_one_hour = two_day + base::TimeDelta::FromHours(1);
+  Experiment hour_experiment;
+  hour_experiment.AssignGroup(5);
+  hour_experiment.SetDisplayTime(two_day_one_hour);
+  int diff_hour =
+      hour_experiment.metrics().toast_hour - experiment.metrics().toast_hour;
+  EXPECT_EQ(1, diff_hour);
+}
+
+TEST(ExperimentTest, TestSetUserSessionUptime) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+  experiment.SetUserSessionUptime(base::TimeDelta::FromMinutes(0));
+  EXPECT_EQ(0, experiment.metrics().session_length_bucket);
+  EXPECT_EQ(0, experiment.user_session_uptime().InMinutes());
+
+  experiment.SetUserSessionUptime(base::TimeDelta::FromMinutes(60));
+  EXPECT_EQ(24, experiment.metrics().session_length_bucket);
+  EXPECT_EQ(60, experiment.user_session_uptime().InMinutes());
+
+  experiment.SetUserSessionUptime(base::TimeDelta::FromMinutes(60 * 24));
+  EXPECT_EQ(43, experiment.metrics().session_length_bucket);
+  EXPECT_EQ(60 * 24, experiment.user_session_uptime().InMinutes());
+
+  experiment.SetUserSessionUptime(
+      base::TimeDelta::FromMinutes(ExperimentMetrics::kMaxSessionLength));
+  EXPECT_EQ(63, experiment.metrics().session_length_bucket);
+  EXPECT_EQ(ExperimentMetrics::kMaxSessionLength,
+            experiment.user_session_uptime().InMinutes());
+
+  experiment.SetUserSessionUptime(
+      base::TimeDelta::FromMinutes(2 * ExperimentMetrics::kMaxSessionLength));
+  EXPECT_EQ(63, experiment.metrics().session_length_bucket);
+  EXPECT_EQ(2 * ExperimentMetrics::kMaxSessionLength,
+            experiment.user_session_uptime().InMinutes());
+}
+
+TEST(ExperimentTest, TestSetActionDelay) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+  experiment.SetActionDelay(base::TimeDelta::FromSeconds(0));
+  EXPECT_EQ(0, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(0, experiment.user_session_uptime().InSeconds());
+
+  experiment.SetActionDelay(base::TimeDelta::FromSeconds(60));
+  EXPECT_EQ(10, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(60, experiment.action_delay().InSeconds());
+
+  experiment.SetActionDelay(base::TimeDelta::FromSeconds(60 * 60));
+  EXPECT_EQ(19, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(60 * 60, experiment.action_delay().InSeconds());
+
+  experiment.SetActionDelay(
+      base::TimeDelta::FromSeconds(ExperimentMetrics::kMaxActionDelay));
+  EXPECT_EQ(31, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(ExperimentMetrics::kMaxActionDelay,
+            experiment.action_delay().InSeconds());
+
+  experiment.SetActionDelay(
+      base::TimeDelta::FromSeconds(2 * ExperimentMetrics::kMaxActionDelay));
+  EXPECT_EQ(31, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(2 * ExperimentMetrics::kMaxActionDelay,
+            experiment.action_delay().InSeconds());
+}
+
+TEST(ExperimentTest, TestAllSetters) {
+  Experiment experiment;
+  experiment.AssignGroup(5);
+  experiment.SetState(ExperimentMetrics::kGroupAssigned);
+  experiment.SetToastLocation(ExperimentMetrics::kOverTaskbarPin);
+  experiment.SetInactiveDays(1621);
+  experiment.SetToastCount(1);
+  base::Time test_display_time =
+      (base::Time::UnixEpoch() +
+       base::TimeDelta::FromSeconds(
+           ExperimentMetrics::kExperimentStartSeconds) +
+       base::TimeDelta::FromDays(30) + base::TimeDelta::FromHours(3));
+  experiment.SetDisplayTime(test_display_time);
+  experiment.SetUserSessionUptime(base::TimeDelta::FromMinutes(3962));
+  experiment.SetActionDelay(base::TimeDelta::FromSeconds(32875));
+
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.state());
+  EXPECT_EQ(5, experiment.group());
+  EXPECT_EQ(ExperimentMetrics::kOverTaskbarPin, experiment.toast_location());
+  EXPECT_EQ(1621, experiment.inactive_days());
+  EXPECT_EQ(1, experiment.toast_count());
+  EXPECT_EQ(test_display_time, experiment.first_display_time());
+  EXPECT_EQ(test_display_time, experiment.latest_display_time());
+  EXPECT_EQ(base::TimeDelta::FromMinutes(3962),
+            experiment.user_session_uptime());
+  EXPECT_EQ(base::TimeDelta::FromSeconds(32875), experiment.action_delay());
+
+  EXPECT_EQ(ExperimentMetrics::kGroupAssigned, experiment.metrics().state);
+  EXPECT_EQ(5, experiment.metrics().group);
+  EXPECT_EQ(ExperimentMetrics::kOverTaskbarPin,
+            experiment.metrics().toast_location);
+  EXPECT_EQ(1, experiment.metrics().toast_count);
+  EXPECT_EQ(30, experiment.metrics().first_toast_offset);
+  EXPECT_EQ(125, experiment.metrics().last_used_bucket);
+  EXPECT_EQ(24, experiment.metrics().action_delay_bucket);
+  EXPECT_EQ(49, experiment.metrics().session_length_bucket);
+}
+
+}  // namespace installer