ui/events/android/motion_event_android_unittest.cc - chromium/src - Git at Google

 // Copyright 2014 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include <android/input.h>
 #include <stddef.h>

 #include <cmath>
 #include <limits>

 #include "base/android/build_info.h"
 #include "base/android/jni_android.h"
 #include "base/android/scoped_java_ref.h"
 #include "base/numerics/angle_conversions.h"
 #include "base/test/scoped_feature_list.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/base/ui_base_features.h"
 #include "ui/events/android/motion_event_android_java.h"
 #include "ui/events/android/motion_event_android_native.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/test/motion_event_test_utils.h"
 #include "ui/events/test/scoped_event_test_tick_clock.h"

 // Must come after all headers that specialize FromJniType() / ToJniType().
 #include "ui/events/motionevent_jni_headers/MotionEvent_jni.h"

 namespace ui {

 class MotionEvent;

 namespace {

 constexpr float kPixToDip = 0.5f;

 constexpr int kAndroidActionButton = 0;
 constexpr int kAndroidActionDown = AMOTION_EVENT_ACTION_DOWN;
 constexpr int kAndroidActionUp = AMOTION_EVENT_ACTION_UP;
 constexpr int kAndroidActionPointerDown = AMOTION_EVENT_ACTION_POINTER_DOWN;
 constexpr int kAndroidAltKeyDown = AMETA_ALT_ON;

 // Corresponds to TOOL_TYPE_FINGER, see
 // developer.android.com/reference/android/view/MotionEvent.html
 //     #TOOL_TYPE_FINGER.
 constexpr int kAndroidToolTypeFinger = 1;

 // Corresponds to BUTTON_PRIMARY, see
 // developer.android.com/reference/android/view/MotionEvent.html#BUTTON_PRIMARY.
 constexpr int kAndroidButtonPrimary = 1;

 // This function convert tilt_x and tilt_y back to tilt_rad.
 float ConvertToTiltRad(float tilt_x, float tilt_y) {
   float tilt_x_r = sinf(base::DegToRad(tilt_x));
   float tilt_x_z = cosf(base::DegToRad(tilt_x));
   float tilt_y_r = sinf(base::DegToRad(tilt_y));
   float tilt_y_z = cosf(base::DegToRad(tilt_y));
   float r_x = tilt_x_r * tilt_y_z;
   float r_y = tilt_y_r * tilt_x_z;
   float r = sqrtf(r_x * r_x + r_y * r_y);
   float z = tilt_x_z * tilt_y_z;
   return atan2f(r, z);
 }

 }  // namespace

 constexpr float float_error = 0.0001f;
 // Note that these tests avoid creating a Java instance of the MotionEvent, as
 // we're primarily testing caching behavior, and the code necessary to
 // construct a Java-backed MotionEvent itself adds unnecessary complexity.
 TEST(MotionEventAndroidTest, Constructor) {
   constexpr int kLatestEventTimeNS = 5'123'456;
   constexpr int kOldestEventTimeNS = 4'123'456;
   base::TimeTicks latest_event_time =
       base::TimeTicks() + base::Nanoseconds(kLatestEventTimeNS);
   base::TimeTicks oldest_event_time =
       base::TimeTicks() + base::Nanoseconds(kOldestEventTimeNS);
   const base::TimeTicks down_time_ms =
       base::TimeTicks::FromUptimeMillis(oldest_event_time.ToUptimeMillis());

   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(latest_event_time);

   const float pressure_0 = 1.5f;
   const float pressure_1 = 2.5f;
   MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, pressure_0, 0.1f,
                                  0.2f, kAndroidToolTypeFinger);
   MotionEventAndroid::Pointer p1(2, -13.7f, 7.13f, 3.5f, 12.1f, pressure_1,
                                  -0.1f, 0.4f, kAndroidToolTypeFinger);
   float raw_offset = -3.f;
   int pointer_count = 2;
   int history_size = 0;
   int action_index = -1;
   MotionEventAndroidJava event(
       base::android::AttachCurrentThread(), nullptr, kPixToDip, 0.f, 0.f, 0.f,
       oldest_event_time, latest_event_time, down_time_ms, kAndroidActionDown,
       pointer_count, history_size, action_index, kAndroidActionButton, 0,
       kAndroidButtonPrimary, kAndroidAltKeyDown, 0, raw_offset, -raw_offset,
       false, &p0, &p1, false);

   EXPECT_EQ(MotionEvent::Action::DOWN, event.GetAction());
   EXPECT_EQ(oldest_event_time, event.GetEventTime());
   EXPECT_EQ(latest_event_time, event.GetLatestEventTime());
   EXPECT_EQ(event.GetDownTime(), down_time_ms);
   EXPECT_EQ(p0.pos_x_pixels * kPixToDip, event.GetX(0));
   EXPECT_EQ(p0.pos_y_pixels * kPixToDip, event.GetY(0));
   EXPECT_EQ(p1.pos_x_pixels * kPixToDip, event.GetX(1));
   EXPECT_EQ(p1.pos_y_pixels * kPixToDip, event.GetY(1));
   EXPECT_FLOAT_EQ((p0.pos_x_pixels + raw_offset) * kPixToDip, event.GetRawX(0));
   EXPECT_FLOAT_EQ((p0.pos_y_pixels - raw_offset) * kPixToDip, event.GetRawY(0));
   EXPECT_FLOAT_EQ((p1.pos_x_pixels + raw_offset) * kPixToDip, event.GetRawX(1));
   EXPECT_FLOAT_EQ((p1.pos_y_pixels - raw_offset) * kPixToDip, event.GetRawY(1));
   EXPECT_EQ(p0.touch_major_pixels * kPixToDip, event.GetTouchMajor(0));
   EXPECT_EQ(p1.touch_major_pixels * kPixToDip, event.GetTouchMajor(1));
   EXPECT_EQ(p0.touch_minor_pixels * kPixToDip, event.GetTouchMinor(0));
   EXPECT_EQ(p1.touch_minor_pixels * kPixToDip, event.GetTouchMinor(1));
   EXPECT_EQ(event.GetPressure(0), pressure_0);
   EXPECT_EQ(event.GetPressure(1), pressure_1);
   EXPECT_EQ(p0.orientation_rad, event.GetOrientation(0));
   EXPECT_EQ(p1.orientation_rad, event.GetOrientation(1));
   EXPECT_NEAR(p0.tilt_rad,
               ConvertToTiltRad(event.GetTiltX(0), event.GetTiltY(0)),
               float_error);
   EXPECT_NEAR(p1.tilt_rad,
               ConvertToTiltRad(event.GetTiltX(1), event.GetTiltY(1)),
               float_error);
   EXPECT_EQ(p0.id, event.GetPointerId(0));
   EXPECT_EQ(p1.id, event.GetPointerId(1));
   EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(0));
   EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(1));
   EXPECT_EQ(MotionEvent::BUTTON_PRIMARY, event.GetButtonState());
   EXPECT_EQ(ui::EF_ALT_DOWN | ui::EF_LEFT_MOUSE_BUTTON, event.GetFlags());
   EXPECT_EQ(static_cast<size_t>(pointer_count), event.GetPointerCount());
   EXPECT_EQ(static_cast<size_t>(history_size), event.GetHistorySize());
 }

 TEST(MotionEventAndroidTest, ZeroPressureOnActionUpEvent) {
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(base::TimeTicks());

   const float pressure = 0.4f;
   MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, pressure, 0.1f,
                                  0.2f, kAndroidToolTypeFinger);
   MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
                                kPixToDip, 0, 0, 0, base::TimeTicks(),
                                kAndroidActionUp, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
                                false, &p0, nullptr);

   EXPECT_EQ(event.GetPressure(0), 0.f);
 }

 TEST(MotionEventAndroidTest, Clone) {
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(base::TimeTicks());

   const int pointer_count = 1;
   MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
                                  kAndroidToolTypeFinger);
   MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
                                kPixToDip, 0, 0, 0, base::TimeTicks(),
                                kAndroidActionDown, pointer_count, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, false, &p0, nullptr);

   std::unique_ptr<MotionEvent> clone = event.Clone();
   EXPECT_EQ(ui::test::ToString(event), ui::test::ToString(*clone));
 }

 TEST(MotionEventAndroidTest, Cancel) {
   constexpr const int kEventTimeNS = 5'123'456;
   base::TimeTicks event_time =
       base::TimeTicks() + base::Nanoseconds(kEventTimeNS);
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(event_time);

   const int pointer_count = 1;
   MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
                                  kAndroidToolTypeFinger);
   MotionEventAndroidJava event(
       base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
       base::TimeTicks() + base::Nanoseconds(kEventTimeNS), kAndroidActionDown,
       pointer_count, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, &p0, nullptr);

   std::unique_ptr<MotionEvent> cancel_event = event.Cancel();
   EXPECT_EQ(MotionEvent::Action::CANCEL, cancel_event->GetAction());
   EXPECT_EQ(event_time, cancel_event->GetEventTime());
   EXPECT_EQ(p0.pos_x_pixels * kPixToDip, cancel_event->GetX(0));
   EXPECT_EQ(p0.pos_y_pixels * kPixToDip, cancel_event->GetY(0));
   EXPECT_EQ(static_cast<size_t>(pointer_count),
             cancel_event->GetPointerCount());
   EXPECT_EQ(0U, cancel_event->GetHistorySize());
 }

 TEST(MotionEventAndroidTest, InvalidOrientationsSanitized) {
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(base::TimeTicks());

   int pointer_count = 2;
   float orientation0 = 1e10f;
   float orientation1 = std::numeric_limits<float>::quiet_NaN();
   MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, orientation0, 0, 0);
   MotionEventAndroid::Pointer p1(1, 0, 0, 0, 0, 0, orientation1, 0, 0);
   MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
                                kPixToDip, 0, 0, 0, base::TimeTicks(),
                                kAndroidActionDown, pointer_count, 0, 0, 0, 0, 0,
                                0, 0, 0, 0, false, &p0, &p1);

   EXPECT_EQ(0.f, event.GetOrientation(0));
   EXPECT_EQ(0.f, event.GetOrientation(1));
 }

 TEST(MotionEventAndroidTest, NonEmptyHistoryForNonMoveEventsSanitized) {
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(base::TimeTicks());

   int pointer_count = 1;
   size_t history_size = 5;
   MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, 0, 0, 0);
   MotionEventAndroidJava event(
       base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
       base::TimeTicks(), base::TimeTicks(), base::TimeTicks(),
       kAndroidActionDown, pointer_count, history_size, 0, 0, 0, 0, 0, 0, 0, 0,
       false, &p0, nullptr, false);

   EXPECT_EQ(0U, event.GetHistorySize());
 }

 TEST(MotionEventAndroidTest, ActionIndexForPointerDown) {
   ui::test::ScopedEventTestTickClock clock;
   clock.SetNowTicks(base::TimeTicks());

   MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
                                  kAndroidToolTypeFinger);
   MotionEventAndroid::Pointer p1(2, -13.7f, 7.13f, 3.5f, 12.1f, 4.0f, -0.1f,
                                  -0.4f, kAndroidToolTypeFinger);
   int pointer_count = 2;
   int history_size = 0;
   int action_index = 1;
   MotionEventAndroidJava event(
       base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
       base::TimeTicks(), kAndroidActionPointerDown, pointer_count, history_size,
       action_index, 0, 0, 0, 0, 0, 0, 0, false, &p0, &p1);

   EXPECT_EQ(MotionEvent::Action::POINTER_DOWN, event.GetAction());
   EXPECT_EQ(action_index, event.GetActionIndex());
 }

 TEST(MotionEventAndroidTest, NativeBackedConstructor) {
   if (base::android::BuildInfo::GetInstance()->sdk_int() <
       base::android::SDK_VERSION_S) {
     GTEST_SKIP()
         << "AMotionEvent_fromJava used in test is only available on S+";
   }

   const float x = 100;
   const float y = 200;
   // Java_MotionEvent_obtain expects timestamps(down time, event time) obtained
   // from |SystemClock#uptimeMillis()|.
   const jlong down_time_ms = base::TimeTicks::Now().ToUptimeMillis();
   const jlong event_time_ms = down_time_ms;
   JNIEnv* env = base::android::AttachCurrentThread();
   base::android::ScopedJavaLocalRef<jobject> java_motion_event =
       JNI_MotionEvent::Java_MotionEvent_obtain(env, down_time_ms, event_time_ms,
                                                kAndroidActionDown, x, y,
                                                kAndroidAltKeyDown);
   const AInputEvent* native_event = nullptr;
   if (__builtin_available(android 31, *)) {
     native_event = AMotionEvent_fromJava(env, java_motion_event.obj());
   }
   CHECK(native_event != nullptr);

   std::unique_ptr<MotionEventAndroid> event = MotionEventAndroidNative::Create(
       base::android::ScopedInputEvent(native_event), kPixToDip,
       /* y_offset_pix= */ 0,
       /* event_times= */ std::nullopt);

   EXPECT_EQ(event->GetX(0), x * kPixToDip);
   EXPECT_EQ(event->GetY(0), y * kPixToDip);
   EXPECT_EQ(event->GetAction(), MotionEvent::Action::DOWN);
   EXPECT_EQ(event->GetFlags(), ui::EF_ALT_DOWN);

   EXPECT_EQ(event->GetEventTime(),
             base::TimeTicks::FromUptimeMillis(event_time_ms));
   EXPECT_EQ(event->GetDownTime(),
             base::TimeTicks::FromUptimeMillis(down_time_ms));
 }

 }  // namespace ui
	// Copyright 2014 The Chromium Authors
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include <android/input.h>
	#include <stddef.h>

	#include <cmath>
	#include <limits>

	#include "base/android/build_info.h"
	#include "base/android/jni_android.h"
	#include "base/android/scoped_java_ref.h"
	#include "base/numerics/angle_conversions.h"
	#include "base/test/scoped_feature_list.h"
	#include "testing/gtest/include/gtest/gtest.h"
	#include "ui/base/ui_base_features.h"
	#include "ui/events/android/motion_event_android_java.h"
	#include "ui/events/android/motion_event_android_native.h"
	#include "ui/events/event_constants.h"
	#include "ui/events/test/motion_event_test_utils.h"
	#include "ui/events/test/scoped_event_test_tick_clock.h"

	// Must come after all headers that specialize FromJniType() / ToJniType().
	#include "ui/events/motionevent_jni_headers/MotionEvent_jni.h"

	namespace ui {

	class MotionEvent;

	namespace {

	constexpr float kPixToDip = 0.5f;

	constexpr int kAndroidActionButton = 0;
	constexpr int kAndroidActionDown = AMOTION_EVENT_ACTION_DOWN;
	constexpr int kAndroidActionUp = AMOTION_EVENT_ACTION_UP;
	constexpr int kAndroidActionPointerDown = AMOTION_EVENT_ACTION_POINTER_DOWN;
	constexpr int kAndroidAltKeyDown = AMETA_ALT_ON;

	// Corresponds to TOOL_TYPE_FINGER, see
	// developer.android.com/reference/android/view/MotionEvent.html
	// #TOOL_TYPE_FINGER.
	constexpr int kAndroidToolTypeFinger = 1;

	// Corresponds to BUTTON_PRIMARY, see
	// developer.android.com/reference/android/view/MotionEvent.html#BUTTON_PRIMARY.
	constexpr int kAndroidButtonPrimary = 1;

	// This function convert tilt_x and tilt_y back to tilt_rad.
	float ConvertToTiltRad(float tilt_x, float tilt_y) {
	float tilt_x_r = sinf(base::DegToRad(tilt_x));
	float tilt_x_z = cosf(base::DegToRad(tilt_x));
	float tilt_y_r = sinf(base::DegToRad(tilt_y));
	float tilt_y_z = cosf(base::DegToRad(tilt_y));
	float r_x = tilt_x_r * tilt_y_z;
	float r_y = tilt_y_r * tilt_x_z;
	float r = sqrtf(r_x * r_x + r_y * r_y);
	float z = tilt_x_z * tilt_y_z;
	return atan2f(r, z);
	}

	} // namespace

	constexpr float float_error = 0.0001f;
	// Note that these tests avoid creating a Java instance of the MotionEvent, as
	// we're primarily testing caching behavior, and the code necessary to
	// construct a Java-backed MotionEvent itself adds unnecessary complexity.
	TEST(MotionEventAndroidTest, Constructor) {
	constexpr int kLatestEventTimeNS = 5'123'456;
	constexpr int kOldestEventTimeNS = 4'123'456;
	base::TimeTicks latest_event_time =
	base::TimeTicks() + base::Nanoseconds(kLatestEventTimeNS);
	base::TimeTicks oldest_event_time =
	base::TimeTicks() + base::Nanoseconds(kOldestEventTimeNS);
	const base::TimeTicks down_time_ms =
	base::TimeTicks::FromUptimeMillis(oldest_event_time.ToUptimeMillis());

	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(latest_event_time);

	const float pressure_0 = 1.5f;
	const float pressure_1 = 2.5f;
	MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, pressure_0, 0.1f,
	0.2f, kAndroidToolTypeFinger);
	MotionEventAndroid::Pointer p1(2, -13.7f, 7.13f, 3.5f, 12.1f, pressure_1,
	-0.1f, 0.4f, kAndroidToolTypeFinger);
	float raw_offset = -3.f;
	int pointer_count = 2;
	int history_size = 0;
	int action_index = -1;
	MotionEventAndroidJava event(
	base::android::AttachCurrentThread(), nullptr, kPixToDip, 0.f, 0.f, 0.f,
	oldest_event_time, latest_event_time, down_time_ms, kAndroidActionDown,
	pointer_count, history_size, action_index, kAndroidActionButton, 0,
	kAndroidButtonPrimary, kAndroidAltKeyDown, 0, raw_offset, -raw_offset,
	false, &p0, &p1, false);

	EXPECT_EQ(MotionEvent::Action::DOWN, event.GetAction());
	EXPECT_EQ(oldest_event_time, event.GetEventTime());
	EXPECT_EQ(latest_event_time, event.GetLatestEventTime());
	EXPECT_EQ(event.GetDownTime(), down_time_ms);
	EXPECT_EQ(p0.pos_x_pixels * kPixToDip, event.GetX(0));
	EXPECT_EQ(p0.pos_y_pixels * kPixToDip, event.GetY(0));
	EXPECT_EQ(p1.pos_x_pixels * kPixToDip, event.GetX(1));
	EXPECT_EQ(p1.pos_y_pixels * kPixToDip, event.GetY(1));
	EXPECT_FLOAT_EQ((p0.pos_x_pixels + raw_offset) * kPixToDip, event.GetRawX(0));
	EXPECT_FLOAT_EQ((p0.pos_y_pixels - raw_offset) * kPixToDip, event.GetRawY(0));
	EXPECT_FLOAT_EQ((p1.pos_x_pixels + raw_offset) * kPixToDip, event.GetRawX(1));
	EXPECT_FLOAT_EQ((p1.pos_y_pixels - raw_offset) * kPixToDip, event.GetRawY(1));
	EXPECT_EQ(p0.touch_major_pixels * kPixToDip, event.GetTouchMajor(0));
	EXPECT_EQ(p1.touch_major_pixels * kPixToDip, event.GetTouchMajor(1));
	EXPECT_EQ(p0.touch_minor_pixels * kPixToDip, event.GetTouchMinor(0));
	EXPECT_EQ(p1.touch_minor_pixels * kPixToDip, event.GetTouchMinor(1));
	EXPECT_EQ(event.GetPressure(0), pressure_0);
	EXPECT_EQ(event.GetPressure(1), pressure_1);
	EXPECT_EQ(p0.orientation_rad, event.GetOrientation(0));
	EXPECT_EQ(p1.orientation_rad, event.GetOrientation(1));
	EXPECT_NEAR(p0.tilt_rad,
	ConvertToTiltRad(event.GetTiltX(0), event.GetTiltY(0)),
	float_error);
	EXPECT_NEAR(p1.tilt_rad,
	ConvertToTiltRad(event.GetTiltX(1), event.GetTiltY(1)),
	float_error);
	EXPECT_EQ(p0.id, event.GetPointerId(0));
	EXPECT_EQ(p1.id, event.GetPointerId(1));
	EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(0));
	EXPECT_EQ(MotionEvent::ToolType::FINGER, event.GetToolType(1));
	EXPECT_EQ(MotionEvent::BUTTON_PRIMARY, event.GetButtonState());
	EXPECT_EQ(ui::EF_ALT_DOWN \| ui::EF_LEFT_MOUSE_BUTTON, event.GetFlags());
	EXPECT_EQ(static_cast<size_t>(pointer_count), event.GetPointerCount());
	EXPECT_EQ(static_cast<size_t>(history_size), event.GetHistorySize());
	}

	TEST(MotionEventAndroidTest, ZeroPressureOnActionUpEvent) {
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(base::TimeTicks());

	const float pressure = 0.4f;
	MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, pressure, 0.1f,
	0.2f, kAndroidToolTypeFinger);
	MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
	kPixToDip, 0, 0, 0, base::TimeTicks(),
	kAndroidActionUp, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	false, &p0, nullptr);

	EXPECT_EQ(event.GetPressure(0), 0.f);
	}

	TEST(MotionEventAndroidTest, Clone) {
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(base::TimeTicks());

	const int pointer_count = 1;
	MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
	kAndroidToolTypeFinger);
	MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
	kPixToDip, 0, 0, 0, base::TimeTicks(),
	kAndroidActionDown, pointer_count, 0, 0, 0, 0, 0,
	0, 0, 0, 0, false, &p0, nullptr);

	std::unique_ptr<MotionEvent> clone = event.Clone();
	EXPECT_EQ(ui::test::ToString(event), ui::test::ToString(*clone));
	}

	TEST(MotionEventAndroidTest, Cancel) {
	constexpr const int kEventTimeNS = 5'123'456;
	base::TimeTicks event_time =
	base::TimeTicks() + base::Nanoseconds(kEventTimeNS);
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(event_time);

	const int pointer_count = 1;
	MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
	kAndroidToolTypeFinger);
	MotionEventAndroidJava event(
	base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
	base::TimeTicks() + base::Nanoseconds(kEventTimeNS), kAndroidActionDown,
	pointer_count, 0, 0, 0, 0, 0, 0, 0, 0, 0, false, &p0, nullptr);

	std::unique_ptr<MotionEvent> cancel_event = event.Cancel();
	EXPECT_EQ(MotionEvent::Action::CANCEL, cancel_event->GetAction());
	EXPECT_EQ(event_time, cancel_event->GetEventTime());
	EXPECT_EQ(p0.pos_x_pixels * kPixToDip, cancel_event->GetX(0));
	EXPECT_EQ(p0.pos_y_pixels * kPixToDip, cancel_event->GetY(0));
	EXPECT_EQ(static_cast<size_t>(pointer_count),
	cancel_event->GetPointerCount());
	EXPECT_EQ(0U, cancel_event->GetHistorySize());
	}

	TEST(MotionEventAndroidTest, InvalidOrientationsSanitized) {
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(base::TimeTicks());

	int pointer_count = 2;
	float orientation0 = 1e10f;
	float orientation1 = std::numeric_limits<float>::quiet_NaN();
	MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, orientation0, 0, 0);
	MotionEventAndroid::Pointer p1(1, 0, 0, 0, 0, 0, orientation1, 0, 0);
	MotionEventAndroidJava event(base::android::AttachCurrentThread(), nullptr,
	kPixToDip, 0, 0, 0, base::TimeTicks(),
	kAndroidActionDown, pointer_count, 0, 0, 0, 0, 0,
	0, 0, 0, 0, false, &p0, &p1);

	EXPECT_EQ(0.f, event.GetOrientation(0));
	EXPECT_EQ(0.f, event.GetOrientation(1));
	}

	TEST(MotionEventAndroidTest, NonEmptyHistoryForNonMoveEventsSanitized) {
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(base::TimeTicks());

	int pointer_count = 1;
	size_t history_size = 5;
	MotionEventAndroid::Pointer p0(0, 0, 0, 0, 0, 0, 0, 0, 0);
	MotionEventAndroidJava event(
	base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
	base::TimeTicks(), base::TimeTicks(), base::TimeTicks(),
	kAndroidActionDown, pointer_count, history_size, 0, 0, 0, 0, 0, 0, 0, 0,
	false, &p0, nullptr, false);

	EXPECT_EQ(0U, event.GetHistorySize());
	}

	TEST(MotionEventAndroidTest, ActionIndexForPointerDown) {
	ui::test::ScopedEventTestTickClock clock;
	clock.SetNowTicks(base::TimeTicks());

	MotionEventAndroid::Pointer p0(1, 13.7f, -7.13f, 5.3f, 1.2f, 0.4f, 0.1f, 0.2f,
	kAndroidToolTypeFinger);
	MotionEventAndroid::Pointer p1(2, -13.7f, 7.13f, 3.5f, 12.1f, 4.0f, -0.1f,
	-0.4f, kAndroidToolTypeFinger);
	int pointer_count = 2;
	int history_size = 0;
	int action_index = 1;
	MotionEventAndroidJava event(
	base::android::AttachCurrentThread(), nullptr, kPixToDip, 0, 0, 0,
	base::TimeTicks(), kAndroidActionPointerDown, pointer_count, history_size,
	action_index, 0, 0, 0, 0, 0, 0, 0, false, &p0, &p1);

	EXPECT_EQ(MotionEvent::Action::POINTER_DOWN, event.GetAction());
	EXPECT_EQ(action_index, event.GetActionIndex());
	}

	TEST(MotionEventAndroidTest, NativeBackedConstructor) {
	if (base::android::BuildInfo::GetInstance()->sdk_int() <
	base::android::SDK_VERSION_S) {
	GTEST_SKIP()
	<< "AMotionEvent_fromJava used in test is only available on S+";
	}

	const float x = 100;
	const float y = 200;
	// Java_MotionEvent_obtain expects timestamps(down time, event time) obtained
	// from \|SystemClock#uptimeMillis()\|.
	const jlong down_time_ms = base::TimeTicks::Now().ToUptimeMillis();
	const jlong event_time_ms = down_time_ms;
	JNIEnv* env = base::android::AttachCurrentThread();
	base::android::ScopedJavaLocalRef<jobject> java_motion_event =
	JNI_MotionEvent::Java_MotionEvent_obtain(env, down_time_ms, event_time_ms,
	kAndroidActionDown, x, y,
	kAndroidAltKeyDown);
	const AInputEvent* native_event = nullptr;
	if (__builtin_available(android 31, *)) {
	native_event = AMotionEvent_fromJava(env, java_motion_event.obj());
	}
	CHECK(native_event != nullptr);

	std::unique_ptr<MotionEventAndroid> event = MotionEventAndroidNative::Create(
	base::android::ScopedInputEvent(native_event), kPixToDip,
	/* y_offset_pix= */ 0,
	/* event_times= */ std::nullopt);

	EXPECT_EQ(event->GetX(0), x * kPixToDip);
	EXPECT_EQ(event->GetY(0), y * kPixToDip);
	EXPECT_EQ(event->GetAction(), MotionEvent::Action::DOWN);
	EXPECT_EQ(event->GetFlags(), ui::EF_ALT_DOWN);

	EXPECT_EQ(event->GetEventTime(),
	base::TimeTicks::FromUptimeMillis(event_time_ms));
	EXPECT_EQ(event->GetDownTime(),
	base::TimeTicks::FromUptimeMillis(down_time_ms));
	}

	} // namespace ui