Added touch event permutations test to touch_exploration_controller.

ui/chromeos/touch_exploration_controller_unittest.cc

 // Copyright 2014 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 "ui/chromeos/touch_exploration_controller.h"
 
 #include "base/test/simple_test_tick_clock.h"
 #include "base/time/time.h"
 #include "ui/aura/client/cursor_client.h"
 #include "ui/aura/test/aura_test_base.h"
 #include "ui/aura/test/event_generator.h"
 #include "ui/aura/test/test_cursor_client.h"
 #include "ui/aura/window.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/test/events_test_utils.h"
 #include "ui/gfx/geometry/point.h"
 #include "ui/gl/gl_implementation.h"
 #include "ui/gl/gl_surface.h"
 
 namespace ui {
 
 namespace {
 // Records all mouse and touch events.
 class EventCapturer : public ui::EventHandler {
  public:
@@ skipping 24 matching lines @@
   const ScopedVector<ui::LocatedEvent>& captured_events() const {
     return events_;
   }
 
  private:
   ScopedVector<ui::LocatedEvent> events_;
 
   DISALLOW_COPY_AND_ASSIGN(EventCapturer);
 };
 
+int Factorial(int n) {
+  if (n <= 0)
+    return 0;
+  if (n == 1)
+    return 1;
+  if (n == 2)
+      return 2;
+  return n * Factorial(n - 1);
+}
+
 }  // namespace
 
 class TouchExplorationTest : public aura::test::AuraTestBase {
  public:
   TouchExplorationTest()
       : simulated_clock_(new base::SimpleTestTickClock()) {}
   virtual ~TouchExplorationTest() {}
 
   virtual void SetUp() OVERRIDE {
     if (gfx::GetGLImplementation() == gfx::kGLImplementationNone)
@@ skipping 871 matching lines @@
   EXPECT_EQ(first_touch_location, captured_events[0]->location());
   ClearCapturedEvents();
 
   ui::TouchEvent first_touch_release(
       ui::ET_TOUCH_RELEASED, first_touch_location, 0, Now());
   generator_->Dispatch(&first_touch_release);
   ASSERT_EQ(captured_events.size(), 1u);
   EXPECT_TRUE(IsInNoFingersDownState());
 }
 
+TEST_F(TouchExplorationTest, AllFingerPermutations) {
+  SwitchTouchExplorationMode(true);
+
+  // We will test all permutations of events from three different fingers
+  // to ensure that we return to NO_FINGERS_DOWN when fingers have been
+  // released.
+  ScopedVector<ui::TouchEvent> all_events;
+  for (int touch_id = 0; touch_id < 3; touch_id++){
+    all_events.push_back(
+        new TouchEvent(ui::ET_TOUCH_PRESSED,
+                       gfx::Point(10 * touch_id + 1, 10 * touch_id + 2),

[aboxhall, 2014/06/27 22:37:26]

Suggestion: you could just have x and y values that you increment each time you
use them instead of this; might be a bit easier to read.

e.g.
int x = 30, y = 30;
for (...) {
 ... gfx::Point(x++, y++), ...

(or even one value, but it might be a little tricky to name)

[evy, 2014/06/30 17:33:08]

Done.

+                       touch_id,
+                       Now()));
+    all_events.push_back(
+        new TouchEvent(ui::ET_TOUCH_MOVED,
+                       gfx::Point(10 * touch_id + 3, 10 * touch_id + 4),
+                       touch_id,
+                       Now()));
+    all_events.push_back(
+        new TouchEvent(ui::ET_TOUCH_RELEASED,
+                       gfx::Point(10 * touch_id + 5, 10 * touch_id + 6),
+                       touch_id,
+                       Now()));
+  }
+  const int num_events = all_events.size();
+  const int num_permutations = Factorial(num_events);
+
+  for (int p = 0; p < num_permutations; p++) {
+    std::vector<ui::TouchEvent*> queued_events = all_events.get();
+    std::vector<bool> fingers_pressed(3, false);
+    // current_factorial starts at factorial(num_events - 1)

[aboxhall, 2014/06/27 22:37:26]

This comment is now out of date.

[evy, 2014/06/30 17:33:08]

Done.

+    // and decreases each iteration
+    int current_num_permutations = num_permutations;
+    for (int events_left = num_events; events_left > 0; events_left--) {
+      VLOG(0) << "\nEvents left: " <<  events_left;
+      int index = 0;
+      if (events_left == num_events) {
+        // This is the first event generated. We divide the number
+        // of possible permutations by the number of events to choose from
+        // (which is currently all of them). We then integer divide p by
+        // this new value to decide which event will be first in this
+        // permutation. e.g. If there are 4 events and 24 permutations,
+        // the first 6 permutations will start with the first event.
+        index = p / (current_num_permutations / events_left);

[aboxhall, 2014/06/27 22:37:26]

Thanks, I actually mostly understand this now! However, I think we can still
make it clearer.

These blocks are all equivalent, right?
p % num_permutations === p
and if events_left == 1 then current_num_permutations will also be 1, and 1 % 1
=== 0

So you could collapse this down to just the lines inside the if (events_left >
1) block.

Then it's just a matter of understanding why those couple of lines are the right
thing to do :)

Perhaps we could rewrite it to be clearer, something like ("thinking out loud"
here, this is not necessarily the best way to write it; you might well come up
with something better)...
int sub_permutation = p % current_num_permutations;
int remaining_permutations = current_num_permutations / events_left;
index = sub_permutation / remaining_permutations;
current_num_permutations = remaining_permutations;

Then you could structure your comments around those lines and explain why each
one makes sense.

[evy, 2014/06/30 17:33:08]

Done. I'm not sure if this is clear enough yet. Can you take a look and let me
know what you think?

+        // Now we have one fewer event to deal with. So there are fewer
+        // permuations to consider for the remaining events.
+        // e.g. If now there are 3 events left, there were 24 permutations
+        // but there are now 6 permutations.
+        // Note that the first 2 permutations of these 6 will start with
+        // the first of the remaining events.
+        current_num_permutations /= events_left;
+      } else if (events_left > 1) {
+        // The logic here is similar to the case where there are num_events
+        // left, but we need to adjust the value of p because we are
+        // working with a smaller number of permutations of the fewer
+        // events that are remaining.
+        // e.g. If there are 3 events left, the number of permutations
+        // should be 6. So we want to adjust p (currently 0 to 23 in the
+        // big for loop) to get values between 0 and 5. So we do p % 6
+        VLOG(0) << "p " << p << " current num " << current_num_permutations;
+        index = (p % current_num_permutations) /
+                (current_num_permutations / events_left);
+        current_num_permutations /= events_left;
+      } else if (events_left == 1) {
+        // When there is only one event left to be queued, there is only
+        // one index available.
+        index = 0;
+      }
+      ui::TouchEvent* next_dispatch = queued_events[index];
+      ASSERT_TRUE(next_dispatch != NULL);
+      EventTestApi test_dispatch(next_dispatch);
+      test_dispatch.set_time_stamp(Now());
+      generator_->Dispatch(next_dispatch);
+      queued_events.erase(queued_events.begin() + index);
+      // Note: it is possible to send a touched move event in the state
+      // SINGLE_TAP_RELEASED or TOUCH_EXPLORE_RELEASED
+      // because the events are not always generated in a sensical
+      // order. If there is a LOG(ERROR) for touch moved hit in
+      // InSingleTapOrTouchExploreReleased, that is fine here.
+
+      // Keep track of what fingers have been pressed, to release
+      // only those fingers at the end, so the check for being in
+      // no fingers down can be accurate.
+      if (next_dispatch->type() == ET_TOUCH_PRESSED) {
+        fingers_pressed[next_dispatch->touch_id()] = true;
+      } else if (next_dispatch->type() == ET_TOUCH_RELEASED) {
+        fingers_pressed[next_dispatch->touch_id()] = false;
+      }
+    }
+    ASSERT_EQ(queued_events.size(), 0u);
+
+    // Release fingers recorded as pressed.
+    for(int j = 0; j < int(fingers_pressed.size()); j++){
+      if (fingers_pressed[j] == true) {
+        generator_->ReleaseTouchId(j);
+        fingers_pressed[j] = false;
+      }
+    }
+    AdvanceSimulatedTimePastTapDelay();
+    EXPECT_TRUE(IsInNoFingersDownState());
+    ClearCapturedEvents();
+  }
+}
+
 }  // namespace ui