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;
+  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 34 matching lines @@
 
   void ClearCapturedEvents() {
     event_capturer_.Reset();
   }
 
   void AdvanceSimulatedTimePastTapDelay() {
     simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
     touch_exploration_controller_->CallTapTimerNowForTesting();
   }
 
+  void AdvanceSimulatedTimePastPotentialTapDelay() {
+    simulated_clock_->Advance(base::TimeDelta::FromMilliseconds(1000));
+    touch_exploration_controller_->CallTapTimerNowIfRunningForTesting();
+  }
+
+  void SwitchVLOG(bool turn_on) {
+    touch_exploration_controller_->SwitchVLOG(turn_on);
+  }
+
   void SwitchTouchExplorationMode(bool on) {
     if (!on && touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset();
     } else if (on && !touch_exploration_controller_.get()) {
       touch_exploration_controller_.reset(
           new ui::TouchExplorationController(root_window()));
       touch_exploration_controller_->SetEventHandlerForTesting(
           &event_capturer_);
       cursor_client()->ShowCursor();
       cursor_client()->DisableMouseEvents();
@@ skipping 710 matching lines @@
 // in TwoToOneFinger.
 TEST_F(TouchExplorationTest, TwoToOneFingerRelaseFirst) {
   gfx::Point first_touch_location = gfx::Point(11,12);
   gfx::Point second_touch_location = gfx::Point(21, 22);
   EnterTwoToOne(first_touch_location, second_touch_location);
   const ScopedVector<ui::LocatedEvent>& captured_events = GetCapturedEvents();
   ASSERT_EQ(captured_events.size(), 1u);
   ClearCapturedEvents();
 
   // Actions before release have already been tested in the previous test.
 

[dmazzoni, 2014/07/02 23:05:58]

Delete extra line

   // A release of the first finger should send an event, as the state
   // changes to the wait state.
   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);
   ClearCapturedEvents();
 
   // No events should be sent after the second finger is lifted.
 
@@ skipping 86 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);
+  SwitchVLOG(false);
+  // 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++){
+    int x = 10*touch_id + 1;
+    int y = 10*touch_id + 2;
+    all_events.push_back(new TouchEvent(
+        ui::ET_TOUCH_PRESSED, gfx::Point(x++, y++), touch_id, Now()));
+    all_events.push_back(new TouchEvent(
+        ui::ET_TOUCH_MOVED, gfx::Point(x++, y++), touch_id, Now()));
+    all_events.push_back(new TouchEvent(
+        ui::ET_TOUCH_RELEASED, gfx::Point(x, y), touch_id, Now()));
+  }
+
+  // I'm going to explain this algorithm, and use an example in parentheses.
+  // The example will be all permutations of a b c d.
+  // There are four letters and 4! = 24 permutations.
+  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);
+
+    int current_num_permutations = num_permutations;
+    for (int events_left = num_events; events_left > 0; events_left--) {
+      // |p| indexes to each permutation when there are num_permutations
+      // permutations. (e.g. 0 is abcd, 1 is abdc, 2 is acbd, 3 is acdb...)
+      // But how do we find the index for the current number of permutations?
+      // To find the permutation within the part of the sequence we're
+      // currently looking at, we need a number between 0 and
+      // |current_num_permutations| - 1.
+      // (e.g. if we already chose the first letter, there are 3! = 6
+      // options left, so we do p % 6. So |current_permutation| would go
+      // from 0 to 5 and then reset to 0 again, for all combinations of
+      // whichever three letters are remaining, as we loop through the
+      // permutations)
+      int current_permutation = p % current_num_permutations;
+
+      // Since this is is the total number of permutations starting with
+      // this event and including future events, there could be multiple
+      // values of current_permutation that will generate the same event
+      // in this iteration.
+      // (e.g. If we chose 'a' but have b c d to choose from, we choose b when
+      // |current_permutation| = 0, 1 and c when |current_permutation| = 2, 3.
+      // Note that each letter gets two numbers, which is the next
+      // current_num_permutations, 2! for the two letters left.)
+
+      // Branching out from the first event, there are num_permutations
+      // permutations, and each value of |p| is associated with one of these
+      // permutations. However, once the first event is chosen, there
+      // are now |num_events| - 1 events left, so the number of permutations
+      // for the rest of the events changes, and will always be equal to
+      // the factorial of the events_left.
+      // (e.g. There are 3! = 6 permutations that start with 'a', so if we
+      // start with 'a' there will be 6 ways to then choose from b c d.)
+      // So we now set-up for the next iteration by setting
+      // current_num_permutations to the factorial of the next number of
+      // events left.
+      current_num_permutations /= events_left;
+
+      // To figure out what current event we want to choose, we integer
+      // divide the current permutation by the next current_num_permutations.
+      // (e.g. If there are 4 letters a b c d and 24 permutations, we divide
+      // by 24/4 = 6. Values 0 to 5 when divided by 6 equals 0, so the first
+      // 6 permutations start with 'a', and the last 6 will start with 'd'.
+      // Note that there are 6 that start with 'a' because there are 6
+      // permutations for the next three letters that follow 'a'.)
+      int index = current_permutation / current_num_permutations;
+
+      ui::TouchEvent* next_dispatch = queued_events[index];
+      ASSERT_TRUE(next_dispatch != NULL);
+
+      // |next_dispatch| has to be put in this container so that its time
+      // stamp can be changed to this point in the test, when it is being
+      // dispatched..
+      EventTestApi test_dispatch(next_dispatch);
+      test_dispatch.set_time_stamp(Now());
+      generator_->Dispatch(next_dispatch);
+      queued_events.erase(queued_events.begin() + index);
+
+      // 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;
+      }
+    }
+    AdvanceSimulatedTimePastPotentialTapDelay();
+    EXPECT_TRUE(IsInNoFingersDownState());
+    ClearCapturedEvents();
+  }
+}
+
 }  // namespace ui