53 std::vector<UnitlessTime>& events_consumed_at_frame,
54 bool restart_engine =
false) {
57 std::unique_ptr<Shell> shell = fixture->
CreateShell({
60 .simulate_vsync =
true,
65 configuration.SetEntrypoint(
"onPointerDataPacketMain");
70 events_consumed_at_frame.clear();
71 bool will_draw_new_frame =
true;
72 int events_consumed = 0;
74 auto nativeOnPointerDataPacket = [&events_consumed_at_frame,
75 &will_draw_new_frame, &events_consumed,
78 if (will_draw_new_frame) {
80 will_draw_new_frame =
false;
81 events_consumed_at_frame.push_back(events_consumed);
83 events_consumed_at_frame.back() = events_consumed;
89 ASSERT_TRUE(configuration.IsValid());
90 fixture->
RunEngine(shell.get(), std::move(configuration));
94 new_configuration.SetEntrypoint(
"onPointerDataPacketMain");
95 ASSERT_TRUE(new_configuration.IsValid());
96 fixture->
RestartEngine(shell.get(), std::move(new_configuration));
100 ASSERT_GE(base_latency, 0);
103 int continuous_frame_count = 0;
104 for (
int i = 0; i < num_events; i += 1) {
106 int j =
static_cast<int>((delivery_time(i) - base_latency) / frame_time);
107 if (j == continuous_frame_count) {
108 continuous_frame_count += 1;
110 double random_latency = delivery_time(i) - j * frame_time - base_latency;
111 ASSERT_GE(random_latency, 0);
112 ASSERT_LT(random_latency, frame_time);
116 ASSERT_LT(j, continuous_frame_count);
121 auto simulation = std::async(std::launch::async, [&]() {
124 for (
int i = 0, j = 0; i < num_events; j += 1) {
125 double t = j * frame_time;
126 while (i < num_events && delivery_time(i) <= t) {
149 ASSERT_EQ(events_consumed_at_frame.back(), num_events);
191 Generator extreme = [frame_time, base_latency](
int i) {
193 i * frame_time + base_latency +
194 (i % 2 == 0 ? 0.1 * frame_time : 0.9 * frame_time));
196 constexpr int n = 40;
197 std::vector<int> events_consumed_at_frame;
199 events_consumed_at_frame);
200 int frame_drawn = events_consumed_at_frame.size();
201 ASSERT_GE(frame_drawn, n - 1);
205 events_consumed_at_frame,
true );
206 int frame_drawn_after_restart = events_consumed_at_frame.size();
207 ASSERT_GE(frame_drawn_after_restart, n - 1);
215 Generator double_sampling = [frame_time, base_latency](
int i) {
216 return static_cast<UnitlessTime>(i * 0.5 * frame_time + base_latency);
218 constexpr int n = 40;
219 std::vector<int> events_consumed_at_frame;
221 events_consumed_at_frame);
224 int frame_drawn = events_consumed_at_frame.size();
225 ASSERT_EQ(frame_drawn, n / 2 + 1);
227 for (
int i = 0; i < n / 2; i += 1) {
228 ASSERT_GE(events_consumed_at_frame[i], 2 * i - 1);
235 static constexpr double iphone_xs_times[] = {0.15,
282 constexpr int n =
sizeof(iphone_xs_times) /
sizeof(iphone_xs_times[0]);
286 double base_latency_f = 0.0;
287 for (
int i = 0; i < 10; i++) {
288 base_latency_f += 0.1;
293 Generator iphone_xs_generator = [frame_time, base_latency](
int i) {
294 return base_latency +
295 static_cast<UnitlessTime>(iphone_xs_times[i] * frame_time);
297 std::vector<int> events_consumed_at_frame;
299 frame_time, events_consumed_at_frame);
300 int frame_drawn = events_consumed_at_frame.size();
301 ASSERT_GE(frame_drawn, n - 1);
307 auto settings = CreateSettingsForFixture();
308 std::unique_ptr<Shell> shell = CreateShell({
309 .settings = settings,
311 .simulate_vsync =
true,
316 configuration.SetEntrypoint(
"onPointerDataPacketMain");
319 std::vector<int64_t> result_sequence;
320 auto nativeOnPointerDataPacket = [&reportLatch, &result_sequence](
328 AddNativeCallback(
"NativeOnPointerDataPacket",
330 ASSERT_TRUE(configuration.IsValid());
331 RunEngine(shell.get(), std::move(configuration));
333 auto packet = std::make_unique<PointerDataPacket>(6);
336 packet->SetPointerData(0,
data);
338 packet->SetPointerData(1,
data);
340 packet->SetPointerData(2,
data);
342 packet->SetPointerData(3,
data);
344 packet->SetPointerData(4,
data);
346 packet->SetPointerData(5,
data);
351 size_t expect_length = 6;
352 ASSERT_EQ(result_sequence.size(), expect_length);
366 DestroyShell(std::move(shell));
372 auto settings = CreateSettingsForFixture();
373 std::unique_ptr<Shell> shell = CreateShell({
374 .settings = settings,
376 .simulate_vsync =
true,
381 configuration.SetEntrypoint(
"onPointerDataPacketMain");
384 std::vector<int64_t> result_sequence;
385 auto nativeOnPointerDataPacket = [&reportLatch, &result_sequence](
393 AddNativeCallback(
"NativeOnPointerDataPacket",
395 ASSERT_TRUE(configuration.IsValid());
396 RunEngine(shell.get(), std::move(configuration));
398 auto packet = std::make_unique<PointerDataPacket>(4);
401 packet->SetPointerData(0,
data);
403 packet->SetPointerData(1,
data);
405 packet->SetPointerData(2,
data);
407 packet->SetPointerData(3,
data);
412 size_t expect_length = 6;
413 ASSERT_EQ(result_sequence.size(), expect_length);
429 DestroyShell(std::move(shell));
static RunConfiguration InferFromSettings(const Settings &settings, const fml::RefPtr< fml::TaskRunner > &io_worker=nullptr, IsolateLaunchType launch_type=IsolateLaunchType::kNewGroup)
Attempts to infer a run configuration from the settings object. This tries to create a run configurat...
static void TestSimulatedInputEvents(ShellTest *fixture, int num_events, UnitlessTime base_latency, Generator delivery_time, UnitlessTime frame_time, std::vector< UnitlessTime > &events_consumed_at_frame, bool restart_engine=false)