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