Bound the impact of system instability on chrome instability.

components/browser_watcher/system_session_analyzer_win_unittest.cc

Index: components/browser_watcher/system_session_analyzer_win_unittest.cc
diff --git a/components/browser_watcher/system_session_analyzer_win_unittest.cc b/components/browser_watcher/system_session_analyzer_win_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..5c27cf69d312a159b0a41df77e6cab1397e5ca94
--- /dev/null
+++ b/components/browser_watcher/system_session_analyzer_win_unittest.cc
@@ -0,0 +1,124 @@
+// Copyright 2017 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/browser_watcher/system_session_analyzer_win.h"
+
+#include <utility>
+#include <vector>
+
+#include "base/time/time.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace browser_watcher {
+
+namespace {
+
+const uint16_t kIdSessionStart = 6005U;
+const uint16_t kIdSessionEnd = 6006U;
+const uint16_t kIdSessionEndUnclean = 6008U;
+
+}  // namespace
+
+// Ensure the fetcher retrieves events.
+// Note: disabling test as it requires the test host have at least 1 prior

[Sigurður Ásgeirsson, 2017/03/02 21:52:58]

don't want to be a pest, but did you see this failing? I'd say it's better to
have this test in place if it fails once a year, than not to have it.
However, you'd want to leave a comment here saying "This test fails under
<circumstances>."

[manzagop (departed), 2017/03/06 15:37:40]

Ok. I wasn't sure how prevalent the failures might be. +1 to let's see if it's a
problem.

Done.

+// session.
+TEST(SystemSessionEventFetcherTest, DISABLED_TestRetrieval) {
+  SystemSessionEventFetcher fetcher(1);
+  std::vector<SystemSessionEventFetcher::EventInfo> events;
+  ASSERT_TRUE(fetcher.FetchEvents(&events));
+  EXPECT_EQ(3U, events.size());
+}
+
+// Ensure the fetcher's retrieved events conform to our expectations. This
+// conformance is validated using the SystemSessionAnalyzer. Note that the
+// ability of SystemSessionAnalyzer to validate the conformance is tested below.
+// Note: disabling test as it requires the test host have at least 1 prior
+// session.
+TEST(SystemSessionEventFetcherTest, DISABLED_NoEvent) {
+  SystemSessionEventFetcher fetcher(1U);
+  SystemSessionAnalyzer analyzer(&fetcher);
+  EXPECT_EQ(SystemSessionAnalyzer::CLEAN,
+            analyzer.IsSessionUnclean(base::Time::Now()));
+}
+
+class StubSystemSessionEventFetcher : public SystemSessionEventFetcher {
+ public:
+  StubSystemSessionEventFetcher() : SystemSessionEventFetcher(10U) {}
+
+  bool FetchEvents(std::vector<EventInfo>* event_infos) const override {
+    DCHECK(event_infos);
+    *event_infos = events_;
+    return true;
+  }
+
+  void AddEvent(const EventInfo& info) { events_.push_back(info); }
+
+ private:
+  std::vector<EventInfo> events_;
+};
+
+TEST(SystemSessionAnalyzerTest, StandardCase) {
+  StubSystemSessionEventFetcher fetcher;
+
+  base::Time time = base::Time::Now();
+  fetcher.AddEvent({kIdSessionStart, time});
+  fetcher.AddEvent(
+      {kIdSessionEndUnclean, time - base::TimeDelta::FromSeconds(10)});
+  fetcher.AddEvent({kIdSessionStart, time - base::TimeDelta::FromSeconds(20)});
+  fetcher.AddEvent({kIdSessionEnd, time - base::TimeDelta::FromSeconds(22)});
+  fetcher.AddEvent({kIdSessionStart, time - base::TimeDelta::FromSeconds(28)});
+
+  SystemSessionAnalyzer analyzer(&fetcher);
+
+  EXPECT_EQ(SystemSessionAnalyzer::OUTSIDE_RANGE,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(30)));
+  EXPECT_EQ(SystemSessionAnalyzer::CLEAN,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(25)));
+  EXPECT_EQ(SystemSessionAnalyzer::UNCLEAN,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(20)));
+  EXPECT_EQ(SystemSessionAnalyzer::UNCLEAN,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(15)));
+  EXPECT_EQ(SystemSessionAnalyzer::UNCLEAN,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(10)));
+  EXPECT_EQ(SystemSessionAnalyzer::CLEAN,
+            analyzer.IsSessionUnclean(time - base::TimeDelta::FromSeconds(5)));
+  EXPECT_EQ(SystemSessionAnalyzer::CLEAN,
+            analyzer.IsSessionUnclean(time + base::TimeDelta::FromSeconds(5)));
+}
+
+TEST(SystemSessionAnalyzerTest, NoEvent) {
+  StubSystemSessionEventFetcher fetcher;
+  SystemSessionAnalyzer analyzer(&fetcher);
+  EXPECT_EQ(SystemSessionAnalyzer::FAILED,
+            analyzer.IsSessionUnclean(base::Time::Now()));
+}
+
+TEST(SystemSessionAnalyzerTest, TimeInversion) {
+  StubSystemSessionEventFetcher fetcher;
+
+  base::Time time = base::Time::Now();
+  fetcher.AddEvent({kIdSessionStart, time});
+  fetcher.AddEvent({kIdSessionEnd, time + base::TimeDelta::FromSeconds(1)});
+  fetcher.AddEvent({kIdSessionStart, time - base::TimeDelta::FromSeconds(1)});
+
+  SystemSessionAnalyzer analyzer(&fetcher);
+  EXPECT_EQ(SystemSessionAnalyzer::FAILED,
+            analyzer.IsSessionUnclean(base::Time::Now()));
+}
+
+TEST(SystemSessionAnalyzerTest, IdInversion) {
+  StubSystemSessionEventFetcher fetcher;
+
+  base::Time time = base::Time::Now();
+  fetcher.AddEvent({kIdSessionStart, time});
+  fetcher.AddEvent({kIdSessionStart, time - base::TimeDelta::FromSeconds(1)});
+  fetcher.AddEvent({kIdSessionEnd, time - base::TimeDelta::FromSeconds(2)});
+
+  SystemSessionAnalyzer analyzer(&fetcher);
+  EXPECT_EQ(SystemSessionAnalyzer::FAILED,
+            analyzer.IsSessionUnclean(base::Time::Now()));
+}
+
+}  // namespace browser_watcher