Moterm part 1: Add MotermModel, a "model" for terminal emulation.

apps/moterm/moterm_model_unittest.cc

Index: apps/moterm/moterm_model_unittest.cc
diff --git a/apps/moterm/moterm_model_unittest.cc b/apps/moterm/moterm_model_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..272ffd95fb7d63b0d6bf80a6bbcbc56f861db751
--- /dev/null
+++ b/apps/moterm/moterm_model_unittest.cc
@@ -0,0 +1,203 @@
+// Copyright 2015 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 "apps/moterm/moterm_model.h"
+
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace {
+
+TEST(MotermModelTest, Position) {
+  MotermModel::Position def;
+  EXPECT_EQ(0, def.row);
+  EXPECT_EQ(0, def.column);
+
+  MotermModel::Position pos(12, 34);
+  EXPECT_EQ(12, pos.row);
+  EXPECT_EQ(34, pos.column);
+}
+
+TEST(MotermModelTest, Size) {
+  MotermModel::Size def;
+  EXPECT_EQ(0u, def.rows);
+  EXPECT_EQ(0u, def.columns);
+
+  MotermModel::Size size(12, 34);
+  EXPECT_EQ(12u, size.rows);
+  EXPECT_EQ(34u, size.columns);
+}
+
+TEST(MotermModelTest, Rectangle) {
+  MotermModel::Rectangle def;
+  EXPECT_EQ(0, def.position.row);
+  EXPECT_EQ(0, def.position.column);
+  EXPECT_EQ(0u, def.size.rows);
+  EXPECT_EQ(0u, def.size.columns);
+  EXPECT_TRUE(def.IsEmpty());
+
+  MotermModel::Rectangle rect1(1, 2, 34, 56);
+  EXPECT_EQ(1, rect1.position.row);
+  EXPECT_EQ(2, rect1.position.column);
+  EXPECT_EQ(34u, rect1.size.rows);
+  EXPECT_EQ(56u, rect1.size.columns);
+  EXPECT_FALSE(rect1.IsEmpty());
+
+  MotermModel::Rectangle rect2(1, 2, 0, 0);
+  EXPECT_EQ(1, rect2.position.row);
+  EXPECT_EQ(2, rect2.position.column);
+  EXPECT_EQ(0u, rect2.size.rows);
+  EXPECT_EQ(0u, rect2.size.columns);
+  EXPECT_TRUE(rect2.IsEmpty());
+
+  MotermModel::Rectangle rect3(0, 0, 1, 2);
+  EXPECT_EQ(0, rect3.position.row);
+  EXPECT_EQ(0, rect3.position.column);
+  EXPECT_EQ(1u, rect3.size.rows);
+  EXPECT_EQ(2u, rect3.size.columns);
+  EXPECT_FALSE(rect3.IsEmpty());
+
+  MotermModel::Rectangle rect4(1, 2, 3, 0);
+  EXPECT_EQ(1, rect4.position.row);
+  EXPECT_EQ(2, rect4.position.column);
+  EXPECT_EQ(3u, rect4.size.rows);
+  EXPECT_EQ(0u, rect4.size.columns);
+  EXPECT_TRUE(rect4.IsEmpty());
+
+  MotermModel::Rectangle rect5(1, 2, 0, 3);
+  EXPECT_EQ(1, rect5.position.row);
+  EXPECT_EQ(2, rect5.position.column);
+  EXPECT_EQ(0u, rect5.size.rows);
+  EXPECT_EQ(3u, rect5.size.columns);
+  EXPECT_TRUE(rect5.IsEmpty());
+}
+
+TEST(MotermModelTest, Color) {
+  MotermModel::Color def;
+  EXPECT_EQ(0u, def.red);
+  EXPECT_EQ(0u, def.green);
+  EXPECT_EQ(0u, def.blue);
+
+  MotermModel::Color color(1, 234, 56);
+  EXPECT_EQ(1u, color.red);
+  EXPECT_EQ(234u, color.green);
+  EXPECT_EQ(56u, color.blue);
+}
+
+TEST(MotermModelTest, CharacterInfo) {
+  MotermModel::CharacterInfo char_info(65, MotermModel::kAttributesBold,
+                                       MotermModel::Color(12, 34, 56),
+                                       MotermModel::Color(123, 45, 67));
+  EXPECT_EQ(65u, char_info.code_point);
+  EXPECT_EQ(MotermModel::kAttributesBold, char_info.attributes);
+  EXPECT_EQ(12u, char_info.foreground_color.red);
+  EXPECT_EQ(34u, char_info.foreground_color.green);
+  EXPECT_EQ(56u, char_info.foreground_color.blue);
+  EXPECT_EQ(123u, char_info.background_color.red);
+  EXPECT_EQ(45u, char_info.background_color.green);
+  EXPECT_EQ(67u, char_info.background_color.blue);
+}
+
+TEST(MotermModelTest, StateChanges) {
+  MotermModel::StateChanges state_changes;
+  EXPECT_FALSE(state_changes.cursor_moved);
+  EXPECT_EQ(0u, state_changes.bell_count);
+  EXPECT_TRUE(state_changes.dirty_rect.IsEmpty());
+  EXPECT_FALSE(state_changes.IsDirty());
+  // Should be the same after reset.
+  state_changes.Reset();
+  EXPECT_FALSE(state_changes.cursor_moved);
+  EXPECT_EQ(0u, state_changes.bell_count);
+  EXPECT_TRUE(state_changes.dirty_rect.IsEmpty());
+  EXPECT_FALSE(state_changes.IsDirty());
+
+  state_changes.cursor_moved = true;
+  EXPECT_TRUE(state_changes.IsDirty());
+  state_changes.Reset();
+  EXPECT_FALSE(state_changes.cursor_moved);
+  EXPECT_FALSE(state_changes.IsDirty());
+
+  state_changes.bell_count++;
+  EXPECT_TRUE(state_changes.IsDirty());
+  state_changes.Reset();
+  EXPECT_EQ(0u, state_changes.bell_count);
+  EXPECT_FALSE(state_changes.IsDirty());
+
+  state_changes.dirty_rect = MotermModel::Rectangle(1, 2, 34, 56);
+  EXPECT_TRUE(state_changes.IsDirty());
+  state_changes.Reset();
+  EXPECT_TRUE(state_changes.dirty_rect.IsEmpty());
+  EXPECT_FALSE(state_changes.IsDirty());
+}
+
+TEST(MotermModelTest, Basic) {
+  MotermModel model(MotermModel::Size(43, 132), MotermModel::Size(25, 80));
+
+  MotermModel::Size size = model.GetSize();
+  EXPECT_EQ(25u, size.rows);
+  EXPECT_EQ(80u, size.columns);
+
+  // The cursor should start out at the upper-left.
+  MotermModel::Position cursor_pos = model.GetCursorPosition();
+  EXPECT_EQ(0, cursor_pos.row);
+  EXPECT_EQ(0, cursor_pos.column);
+
+  MotermModel::StateChanges state_changes;
+  EXPECT_FALSE(state_changes.IsDirty());
+
+  // Print "XYZ" in bright (bold) green on red.
+  static const char kXYZ[] = "\x1b[1;32;41mXYZ";
+  model.ProcessInput(kXYZ, sizeof(kXYZ) - 1, &state_changes);
+  EXPECT_TRUE(state_changes.IsDirty());
+  EXPECT_TRUE(state_changes.cursor_moved);
+  EXPECT_EQ(0u, state_changes.bell_count);
+  EXPECT_FALSE(state_changes.dirty_rect.IsEmpty());
+  // The model has some flexibility in the size of the dirty rectangle (it may
+  // over-report), but it should contain the actually-dirty part.
+  EXPECT_LE(state_changes.dirty_rect.position.row, 0);
+  EXPECT_LE(state_changes.dirty_rect.position.column, 0);
+  EXPECT_GE(state_changes.dirty_rect.size.rows, 1u);
+  EXPECT_GE(state_changes.dirty_rect.size.columns, 3u);
+
+  // Get the 'Y'.
+  MotermModel::CharacterInfo char_info =
+      model.GetCharacterInfoAt(MotermModel::Position(0, 1));
+  EXPECT_EQ(static_cast<uint32_t>('Y'), char_info.code_point);
+  EXPECT_EQ(MotermModel::kAttributesBold, char_info.attributes);
+  // The foreground should be (bright) green-ish; this is a guess at what that
+  // means.
+  EXPECT_GE(char_info.foreground_color.green, 100u);
+  EXPECT_GE(char_info.foreground_color.green / 2,
+            char_info.foreground_color.red);
+  EXPECT_GE(char_info.foreground_color.green / 2,
+            char_info.foreground_color.blue);
+  // The background_color should be (non-bright) red-ish.
+  EXPECT_GE(char_info.background_color.red, 50u);
+  EXPECT_GE(char_info.background_color.red / 2,
+            char_info.background_color.green);
+  EXPECT_GE(char_info.background_color.red / 2,
+            char_info.background_color.blue);
+
+  state_changes.Reset();
+  EXPECT_FALSE(state_changes.IsDirty());
+
+  // Now ring the bell three times.
+  static const char kBellBellBell[] = "\a\a\a";
+  model.ProcessInput(kBellBellBell, sizeof(kBellBellBell) - 1, &state_changes);
+  EXPECT_TRUE(state_changes.IsDirty());
+  EXPECT_FALSE(state_changes.cursor_moved);
+  EXPECT_EQ(3u, state_changes.bell_count);
+  EXPECT_TRUE(state_changes.dirty_rect.IsEmpty());
+
+  model.SetSize(MotermModel::Size(43, 132), false);
+  size = model.GetSize();
+  EXPECT_EQ(43u, size.rows);
+  EXPECT_EQ(132u, size.columns);
+
+  model.SetSize(MotermModel::Size(40, 100), true);
+  size = model.GetSize();
+  EXPECT_EQ(40u, size.rows);
+  EXPECT_EQ(100u, size.columns);
+}
+
+}  // namespace