Copy Crashpad into the Chrome tree instead of importing it via DEPS

third_party/crashpad/crashpad/snapshot/win/system_snapshot_win_test.cc

+// Copyright 2015 The Crashpad Authors. All rights reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#include "snapshot/win/system_snapshot_win.h"
+
+#include <sys/time.h>
+#include <time.h>
+
+#include <string>
+
+#include "build/build_config.h"
+#include "gtest/gtest.h"
+#include "snapshot/win/process_reader_win.h"
+
+namespace crashpad {
+namespace test {
+namespace {
+
+class SystemSnapshotWinTest : public testing::Test {
+ public:
+  SystemSnapshotWinTest()
+      : Test(),
+        process_reader_(),
+        system_snapshot_() {
+  }
+
+  const internal::SystemSnapshotWin& system_snapshot() const {
+    return system_snapshot_;
+  }
+
+  // testing::Test:
+  void SetUp() override {
+    ASSERT_TRUE(process_reader_.Initialize(GetCurrentProcess(),
+                                           ProcessSuspensionState::kRunning));
+    system_snapshot_.Initialize(&process_reader_);
+  }
+
+ private:
+  ProcessReaderWin process_reader_;
+  internal::SystemSnapshotWin system_snapshot_;
+
+  DISALLOW_COPY_AND_ASSIGN(SystemSnapshotWinTest);
+};
+
+TEST_F(SystemSnapshotWinTest, GetCPUArchitecture) {
+  CPUArchitecture cpu_architecture = system_snapshot().GetCPUArchitecture();
+
+#if defined(ARCH_CPU_X86)
+  EXPECT_EQ(kCPUArchitectureX86, cpu_architecture);
+#elif defined(ARCH_CPU_X86_64)
+  EXPECT_EQ(kCPUArchitectureX86_64, cpu_architecture);
+#endif
+}
+
+TEST_F(SystemSnapshotWinTest, CPUCount) {
+  EXPECT_GE(system_snapshot().CPUCount(), 1);
+}
+
+TEST_F(SystemSnapshotWinTest, CPUVendor) {
+  std::string cpu_vendor = system_snapshot().CPUVendor();
+
+  // There are a variety of other values, but we don't expect to run our tests
+  // on them.
+  EXPECT_TRUE(cpu_vendor == "GenuineIntel" || cpu_vendor == "AuthenticAMD");
+}
+
+TEST_F(SystemSnapshotWinTest, CPUX86SupportsDAZ) {
+  // Most SSE2+ machines support Denormals-Are-Zero. This may fail if run on
+  // older machines.
+  EXPECT_TRUE(system_snapshot().CPUX86SupportsDAZ());
+}
+
+TEST_F(SystemSnapshotWinTest, GetOperatingSystem) {
+  EXPECT_EQ(SystemSnapshot::kOperatingSystemWindows,
+            system_snapshot().GetOperatingSystem());
+}
+
+TEST_F(SystemSnapshotWinTest, OSVersion) {
+  int major;
+  int minor;
+  int bugfix;
+  std::string build;
+  system_snapshot().OSVersion(&major, &minor, &bugfix, &build);
+
+  EXPECT_GE(major, 5);
+  if (major == 5)
+    EXPECT_GE(minor, 1);
+  if (major == 6)
+    EXPECT_TRUE(minor >= 0 && minor <= 3);
+}
+
+TEST_F(SystemSnapshotWinTest, OSVersionFull) {
+  EXPECT_FALSE(system_snapshot().OSVersionFull().empty());
+}
+
+TEST_F(SystemSnapshotWinTest, MachineDescription) {
+  EXPECT_TRUE(system_snapshot().MachineDescription().empty());
+}
+
+TEST_F(SystemSnapshotWinTest, TimeZone) {
+  SystemSnapshot::DaylightSavingTimeStatus dst_status;
+  int standard_offset_seconds;
+  int daylight_offset_seconds;
+  std::string standard_name;
+  std::string daylight_name;
+
+  system_snapshot().TimeZone(&dst_status,
+                             &standard_offset_seconds,
+                             &daylight_offset_seconds,
+                             &standard_name,
+                             &daylight_name);
+
+  // |standard_offset_seconds| gives seconds east of UTC, and |timezone| gives
+  // seconds west of UTC.
+#if _MSC_VER >= 1900
+  long timezone = 0;
+  _get_timezone(&timezone);
+#endif
+  EXPECT_EQ(-timezone, standard_offset_seconds);
+
+  // In contemporary usage, most time zones have an integer hour offset from
+  // UTC, although several are at a half-hour offset, and two are at 15-minute
+  // offsets. Throughout history, other variations existed. See
+  // http://www.timeanddate.com/time/time-zones-interesting.html.
+  EXPECT_EQ(0, standard_offset_seconds % (15 * 60))
+      << "standard_offset_seconds " << standard_offset_seconds;
+
+  if (dst_status == SystemSnapshot::kDoesNotObserveDaylightSavingTime) {
+    EXPECT_EQ(standard_offset_seconds, daylight_offset_seconds);
+    EXPECT_EQ(standard_name, daylight_name);
+  } else {
+    EXPECT_EQ(0, daylight_offset_seconds % (15 * 60))
+        << "daylight_offset_seconds " << daylight_offset_seconds;
+
+    // In contemporary usage, dst_delta_seconds will almost always be one hour,
+    // except for Lord Howe Island, Australia, which uses a 30-minute
+    // delta. Throughout history, other variations existed. See
+    // http://www.timeanddate.com/time/dst/#brief.
+    int dst_delta_seconds = daylight_offset_seconds - standard_offset_seconds;
+    if (dst_delta_seconds != 60 * 60 && dst_delta_seconds != 30 * 60) {
+      FAIL() << "dst_delta_seconds " << dst_delta_seconds;
+    }
+
+    EXPECT_NE(standard_name, daylight_name);
+  }
+}
+
+}  // namespace
+}  // namespace test
+}  // namespace crashpad