content/browser/renderer_host/input/motion_event_android_unittest.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/android/jni_android.h"
   6 #include "base/float_util.h"
   7 #include "content/browser/renderer_host/input/motion_event_android.h"
   8 #include "testing/gtest/include/gtest/gtest.h"
   9
  10 using ui::MotionEvent;
  11
  12 namespace content {
  13 namespace {
  14 const float kPixToDip = 0.5f;
  15
  16 // Corresponds to ACTION_DOWN, see
  17 // developer.android.com/reference/android/view/MotionEvent.html#ACTION_DOWN.
  18 int kAndroidActionDown = 0;
  19
  20 // Corresponds to TOOL_TYPE_FINGER, see
  21 // developer.android.com/reference/android/view/MotionEvent.html
  22 //     #TOOL_TYPE_FINGER.
  23 int kAndroidToolTypeFinger = 1;
  24
  25 // Corresponds to BUTTON_PRIMARY, see
  26 // developer.android.com/reference/android/view/MotionEvent.html#BUTTON_PRIMARY.
  27 int kAndroidButtonPrimary = 1;
  28
  29 }  // namespace
  30
  31 TEST(MotionEventAndroidTest, Constructor) {
  32   int event_time_ms = 5;
  33   base::TimeTicks event_time =
  34       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
  35   float x0 = 13.7f;
  36   float y0 = -7.13f;
  37   float x1 = -13.7f;
  38   float y1 = 7.13f;
  39   float raw_offset = 10.1f;
  40   float touch_major0 = 5.3f;
  41   float touch_major1 = 3.5f;
  42   float touch_minor0 = 1.2f;
  43   float touch_minor1 = 2.1f;
  44   float orientation0 = 0.1f;
  45   float orientation1 = std::numeric_limits<float>::quiet_NaN();
  46   int p0 = 1;
  47   int p1 = 2;
  48   int pointer_count = 2;
  49   int history_size = 0;
  50   int action_index = -1;
  51   base::android::ScopedJavaLocalRef<jobject> base_event_obj =
  52       MotionEventAndroid::Obtain(
  53           event_time, event_time, MotionEvent::ACTION_DOWN, x0, y0);
  54   ASSERT_TRUE(base_event_obj.obj());
  55
  56   MotionEventAndroid event(kPixToDip,
  57                            base::android::AttachCurrentThread(),
  58                            base_event_obj.obj(),
  59                            event_time_ms,
  60                            kAndroidActionDown,
  61                            pointer_count,
  62                            history_size,
  63                            action_index,
  64                            x0,
  65                            y0,
  66                            x1,
  67                            y1,
  68                            p0,
  69                            p1,
  70                            touch_major0,
  71                            touch_major1,
  72                            touch_minor0,
  73                            touch_minor1,
  74                            orientation0,
  75                            orientation1,
  76                            x0 + raw_offset,
  77                            y0 - raw_offset,
  78                            kAndroidToolTypeFinger,
  79                            kAndroidToolTypeFinger,
  80                            kAndroidButtonPrimary);
  81
  82   EXPECT_EQ(MotionEvent::ACTION_DOWN, event.GetAction());
  83   EXPECT_EQ(event_time, event.GetEventTime());
  84   EXPECT_EQ(x0 * kPixToDip, event.GetX(0));
  85   EXPECT_EQ(y0 * kPixToDip, event.GetY(0));
  86   EXPECT_EQ(x1 * kPixToDip, event.GetX(1));
  87   EXPECT_EQ(y1 * kPixToDip, event.GetY(1));
  88   EXPECT_FLOAT_EQ((x0 + raw_offset) * kPixToDip, event.GetRawX(0));
  89   EXPECT_FLOAT_EQ((y0 - raw_offset) * kPixToDip, event.GetRawY(0));
  90   EXPECT_FLOAT_EQ((x1 + raw_offset) * kPixToDip, event.GetRawX(1));
  91   EXPECT_FLOAT_EQ((y1 - raw_offset) * kPixToDip, event.GetRawY(1));
  92   EXPECT_EQ(touch_major0 * kPixToDip, event.GetTouchMajor(0));
  93   EXPECT_EQ(touch_major1 * kPixToDip, event.GetTouchMajor(1));
  94   EXPECT_EQ(touch_minor0 * kPixToDip, event.GetTouchMinor(0));
  95   EXPECT_EQ(touch_minor1 * kPixToDip, event.GetTouchMinor(1));
  96   EXPECT_EQ(orientation0, event.GetOrientation(0));
  97   EXPECT_EQ(0.f, event.GetOrientation(1));
  98   EXPECT_EQ(p0, event.GetPointerId(0));
  99   EXPECT_EQ(p1, event.GetPointerId(1));
 100   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(0));
 101   EXPECT_EQ(MotionEvent::TOOL_TYPE_FINGER, event.GetToolType(1));
 102   EXPECT_EQ(MotionEvent::BUTTON_PRIMARY, event.GetButtonState());
 103   EXPECT_EQ(static_cast<size_t>(pointer_count), event.GetPointerCount());
 104   EXPECT_EQ(static_cast<size_t>(history_size), event.GetHistorySize());
 105   EXPECT_EQ(action_index, event.GetActionIndex());
 106 }
 107
 108 TEST(MotionEventAndroidTest, Clone) {
 109   int event_time_ms = 5;
 110   base::TimeTicks event_time =
 111       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
 112   float x = 13.7f;
 113   float y = -7.13f;
 114   float touch_major = 5.3f;
 115   float touch_minor = 3.5f;
 116   float orientation = 0.2f;
 117   int pointer_count = 1;
 118   int pointer_id = 1;
 119   base::android::ScopedJavaLocalRef<jobject> event_obj =
 120       MotionEventAndroid::Obtain(
 121           event_time, event_time, MotionEvent::ACTION_DOWN, x, y);
 122   ASSERT_TRUE(event_obj.obj());
 123
 124   MotionEventAndroid event(kPixToDip,
 125                            base::android::AttachCurrentThread(),
 126                            event_obj.obj(),
 127                            event_time_ms,
 128                            kAndroidActionDown,
 129                            pointer_count,
 130                            0,
 131                            0,
 132                            x,
 133                            y,
 134                            0,
 135                            0,
 136                            pointer_id,
 137                            0,
 138                            touch_major,
 139                            0.f,
 140                            touch_minor,
 141                            0.f,
 142                            orientation,
 143                            0.f,
 144                            x,
 145                            y,
 146                            0,
 147                            0,
 148                            0);
 149
 150   scoped_ptr<MotionEvent> clone = event.Clone();
 151   EXPECT_EQ(event, *clone);
 152 }
 153
 154 TEST(MotionEventAndroidTest, Cancel) {
 155   int event_time_ms = 5;
 156   base::TimeTicks event_time =
 157       base::TimeTicks() + base::TimeDelta::FromMilliseconds(event_time_ms);
 158   int pointer_count = 1;
 159   float x = 13.7f;
 160   float y = -7.13f;
 161   base::android::ScopedJavaLocalRef<jobject> event_obj =
 162       MotionEventAndroid::Obtain(
 163           event_time, event_time, MotionEvent::ACTION_DOWN, x, y);
 164   ASSERT_TRUE(event_obj.obj());
 165
 166   MotionEventAndroid event(kPixToDip,
 167                            base::android::AttachCurrentThread(),
 168                            event_obj.obj(),
 169                            event_time_ms,
 170                            kAndroidActionDown,
 171                            pointer_count,
 172                            0,
 173                            0,
 174                            x,
 175                            y,
 176                            0,
 177                            0,
 178                            0,
 179                            0,
 180                            0.f,
 181                            0.f,
 182                            0.f,
 183                            0.f,
 184                            0.f,
 185                            0.f,
 186                            x,
 187                            y,
 188                            0,
 189                            0,
 190                            0);
 191
 192   scoped_ptr<MotionEvent> cancel_event = event.Cancel();
 193   EXPECT_EQ(MotionEvent::ACTION_CANCEL, cancel_event->GetAction());
 194   EXPECT_EQ(event_time, cancel_event->GetEventTime());
 195   EXPECT_EQ(x * kPixToDip, cancel_event->GetX(0));
 196   EXPECT_EQ(y * kPixToDip, cancel_event->GetY(0));
 197   EXPECT_EQ(static_cast<size_t>(pointer_count),
 198             cancel_event->GetPointerCount());
 199   EXPECT_EQ(0U, cancel_event->GetHistorySize());
 200 }
 201
 202 }  // namespace content