Add more options to --screen-config flag.

ui/display/fake_display_snapshot_unittests.cc

Index: ui/display/fake_display_snapshot_unittests.cc
diff --git a/ui/display/fake_display_snapshot_unittests.cc b/ui/display/fake_display_snapshot_unittests.cc
new file mode 100644
index 0000000000000000000000000000000000000000..87086e54230cc3c53d73320b977693947e423c8d
--- /dev/null
+++ b/ui/display/fake_display_snapshot_unittests.cc
@@ -0,0 +1,150 @@
+// 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 "base/macros.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "ui/display/fake_display_snapshot.h"
+#include "ui/display/types/display_snapshot.h"
+
+namespace display {
+
+using DisplayModeList = ui::DisplaySnapshot::DisplayModeList;
+
+namespace {
+
+std::unique_ptr<ui::DisplaySnapshot> CreateSnapshot(const std::string& str) {
+  return FakeDisplaySnapshot::CreateFromSpec(1, str);
+}
+
+}  // namespace
+
+TEST(FakeDisplaySnapshotTest, SizeOnly) {
+  auto display = CreateSnapshot("1024x768");
+
+  ASSERT_EQ(1u, display->modes().size());
+  EXPECT_EQ(1024, display->native_mode()->size().width());
+  EXPECT_EQ(768, display->native_mode()->size().height());
+}
+
+TEST(FakeDisplaySnapshotTest, DefaultTypeIsUnknown) {
+  auto display = CreateSnapshot("1024x768");
+
+  ASSERT_EQ(1u, display->modes().size());
+  EXPECT_EQ(ui::DISPLAY_CONNECTION_TYPE_UNKNOWN, display->type());
+}
+
+TEST(FakeDisplaySnapshotTest, FullNativeMode) {
+  auto display = CreateSnapshot("1024x768%120");
+
+  ASSERT_EQ(1u, display->modes().size());
+  EXPECT_EQ(1024, display->native_mode()->size().width());
+  EXPECT_EQ(768, display->native_mode()->size().height());
+  EXPECT_EQ(120.0f, display->native_mode()->refresh_rate());

[Daniel Erat, 2016/10/07 17:17:22]

mind adding a ModeToString() function that returns e.g. "1024x768%120" to the
anonymous namespace in this file? then you can simplify these checks to a single
statement:

  EXPECT_EQ("1024x768%120", ModeToString(display->native_mode()));

[kylechar, 2016/10/11 13:56:49]

Hmmm, not sure I'm a fan of comparing strings. How about a function that does
the three EXPECT_EQ() calls instead? It would accomplish the same
simplification.

It actually seems like a proper matcher would be ideal here. I actually wrote up
a full gmock matcher based on testing::MatcherInterface<> but it's a ton of
boilerplate. So that doesn't seem worth it, at least in this case.

+}
+
+TEST(FakeDisplaySnapshotTest, FullNativeModeWithDPI) {
+  auto display = CreateSnapshot("1000x1000%120^300");
+
+  ASSERT_EQ(1u, display->modes().size());
+  EXPECT_EQ(1000, display->native_mode()->size().width());
+  EXPECT_EQ(1000, display->native_mode()->size().height());
+  EXPECT_EQ(120.0f, display->native_mode()->refresh_rate());
+  EXPECT_EQ(85, display->physical_size().width());
+  EXPECT_EQ(85, display->physical_size().height());
+}
+
+TEST(FakeDisplaySnapshotTest, InternalDisplayWithSize) {
+  auto display = CreateSnapshot("1600x900/i");
+
+  ASSERT_EQ(1u, display->modes().size());
+  EXPECT_EQ(1600, display->native_mode()->size().width());
+  EXPECT_EQ(900, display->native_mode()->size().height());
+  EXPECT_EQ(ui::DISPLAY_CONNECTION_TYPE_INTERNAL, display->type());
+}
+
+TEST(FakeDisplaySnapshotTest, MultipleOptions) {
+  auto display = CreateSnapshot("1600x900/aci");
+
+  EXPECT_EQ(ui::DISPLAY_CONNECTION_TYPE_INTERNAL, display->type());
+  EXPECT_TRUE(display->has_color_correction_matrix());
+  EXPECT_TRUE(display->is_aspect_preserving_scaling());
+}
+
+TEST(FakeDisplaySnapshotTest, AlternateDisplayModes) {
+  auto display = CreateSnapshot("1920x1080#1600x900:1280x720/i");
+  const DisplayModeList& modes = display->modes();
+
+  ASSERT_EQ(3u, modes.size());
+  EXPECT_EQ(1920, modes[0]->size().width());
+  EXPECT_EQ(1080, modes[0]->size().height());
+  EXPECT_EQ(1600, modes[1]->size().width());
+  EXPECT_EQ(900, modes[1]->size().height());
+  EXPECT_EQ(1280, modes[2]->size().width());
+  EXPECT_EQ(720, modes[2]->size().height());
+  EXPECT_EQ(ui::DISPLAY_CONNECTION_TYPE_INTERNAL, display->type());
+}
+
+TEST(FakeDisplaySnapshotTest, ComplicatedSpecString) {
+  auto display =
+      CreateSnapshot("1920x1080%59.99#1600x900%90:1280x720%120^300/i");
+  const DisplayModeList& modes = display->modes();
+
+  ASSERT_EQ(3u, display->modes().size());
+  EXPECT_EQ(1920, modes[0]->size().width());
+  EXPECT_EQ(1080, modes[0]->size().height());
+  EXPECT_EQ(59.99f, modes[0]->refresh_rate());
+  EXPECT_EQ(1600, modes[1]->size().width());
+  EXPECT_EQ(900, modes[1]->size().height());
+  EXPECT_EQ(90.0f, modes[1]->refresh_rate());
+  EXPECT_EQ(1280, modes[2]->size().width());
+  EXPECT_EQ(720, modes[2]->size().height());
+  EXPECT_EQ(120.0f, modes[2]->refresh_rate());
+  EXPECT_EQ(163, display->physical_size().width());
+  EXPECT_EQ(91, display->physical_size().height());
+  EXPECT_EQ(ui::DISPLAY_CONNECTION_TYPE_INTERNAL, display->type());
+}
+
+TEST(FakeDisplaySnapshotTest, BadDisplayMode) {
+  // Need width and height.
+  EXPECT_EQ(nullptr, CreateSnapshot("1024"));
+  // Display height and width should be separated by 'x' not ','.
+  EXPECT_EQ(nullptr, CreateSnapshot("1024,768"));
+  // Random 'a' before spec starts.
+  EXPECT_EQ(nullptr, CreateSnapshot("a1024,768"));
+  // Need to provide a refresh rate after '%'.
+  EXPECT_EQ(nullptr, CreateSnapshot("1024,768%"));
+  EXPECT_EQ(nullptr, CreateSnapshot("1024,768%a"));
+  // Refresh rate should come before DPI.
+  EXPECT_EQ(nullptr, CreateSnapshot("1000x1000^300%120"));
+}
+
+TEST(FakeDisplaySnapshotTest, BadDPI) {
+  // DPI should be an integer value.
+  EXPECT_EQ(nullptr, CreateSnapshot("1024x768^a"));
+  EXPECT_EQ(nullptr, CreateSnapshot("1024x768^300d"));
+}
+
+TEST(FakeDisplaySnapshotTest, BadOptions) {
+  // Need a '/' before options.
+  EXPECT_EQ(nullptr, CreateSnapshot("1024x768i"));
+  // Character 'z' is not a valid option.
+  EXPECT_EQ(nullptr, CreateSnapshot("1600x900/z"));
+  EXPECT_EQ(nullptr, CreateSnapshot("1600x900/iz"));
+  // DPI should come before options.
+  EXPECT_EQ(nullptr, CreateSnapshot("1600x900/i^300"));
+}
+
+TEST(FakeDisplaySnapshotTest, BadOrderOptionsAndModes) {
+  // Options should come after alternate display modes.
+  auto display = CreateSnapshot("1920x1080/i#1600x900:1280x720");
+  EXPECT_EQ(nullptr, display);
+}
+
+TEST(FakeDisplaySnapshotTest, BadOrderModeSeparator) {
+  // Reverse the '#' and ':' delimiters for alternate display modes.
+  auto display = CreateSnapshot("1920x1080:1600x900#1280x720");
+  EXPECT_EQ(nullptr, display);
+}
+
+}  // namespace display