2 # vim:ts=4:sw=4:expandtab
3 use strict; use warnings;
5 use File::Temp qw(tmpnam tempfile tempdir);
10 use lib qw(@abs_top_srcdir@/AnyEvent-I3/blib/lib);
12 use List::Util qw(first);
13 use Time::HiRes qw(sleep);
15 use POSIX ':sys_wait_h';
16 use Scalar::Util qw(blessed);
18 use i3test::Util qw(slurp);
58 i3test - Testcase setup module
66 my $ws = fresh_workspace;
67 is_num_children($ws, 0, 'no containers on this workspace yet');
69 is_num_children($ws, 1, 'one container after "open"');
75 This module is used in every i3 testcase and takes care of automatically
76 starting i3 before any test instructions run. It also saves you typing of lots
77 of boilerplate in every test file.
80 i3test automatically "use"s C<Test::More>, C<Data::Dumper>, C<AnyEvent::I3>,
81 C<Time::HiRes>’s C<sleep> and C<i3test::Test> so that all of them are available
82 to you in your testcase.
84 See also C<i3test::Test> (L<https://build.i3wm.org/docs/lib-i3test-test.html>)
85 which provides additional test instructions (like C<ok> or C<is>).
89 my $tester = Test::Builder->new();
90 my $_cached_socket_path = undef;
91 my $_sync_window = undef;
92 my $tmp_socket_path = undef;
99 return $window_count++;
107 # Skip the remaining cleanup for testcases which set i3_autostart => 0:
108 return if !defined($i3_pid) && !$i3_autostart;
110 # don't trigger SIGCHLD handler
113 # From perldoc -v '$?':
114 # Inside an "END" subroutine $? contains the value
115 # that is going to be given to "exit()".
117 # Since waitpid sets $?, we need to localize it,
118 # otherwise TAP would be misinterpreted our return status
121 # When measuring code coverage, try to exit i3 cleanly (otherwise, .gcda
122 # files are not written)
123 if ($ENV{COVERAGE} || $ENV{VALGRIND}) {
124 exit_gracefully($i3_pid, "/tmp/nested-$ENV{DISPLAY}");
128 or $tester->BAIL_OUT("could not kill i3: $!");
135 my ($class, %args) = @_;
138 $x ||= i3test::X11->new;
139 # set the pointer to a predictable position in case a previous test has
142 0, # src_window (None)
143 $x->get_root_window(), # dst_window (None)
150 # Synchronize with X11 to ensure the pointer has been warped before i3
152 $x->get_input_focus_reply($x->get_input_focus()->{sequence});
154 $i3_autostart = delete($args{i3_autostart}) // 1;
155 my $i3_config = delete($args{i3_config}) // '-default';
157 my $cv = launch_with_config($i3_config, dont_block => 1)
160 my $test_more_args = '';
161 $test_more_args = join(' ', 'qw(', %args, ')') if keys %args;
165 use Test::More $test_more_args;
168 use Time::HiRes qw(sleep);
171 $tester->BAIL_OUT("$@") if $@;
172 feature->import(":5.10");
176 $cv->recv if $i3_autostart;
179 goto \&Exporter::import;
184 =head2 wait_for_event($timeout, $callback)
186 Waits for the next event and calls the given callback for every event to
187 determine if this is the event we are waiting for.
189 Can be used to wait until a window is mapped, until a ClientMessage is
192 wait_for_event 0.25, sub { $_[0]->{response_type} == MAP_NOTIFY };
196 my ($timeout, $cb) = @_;
200 while (defined(my $event = $x->wait_for_event)) {
201 return 1 if $cb->($event);
205 =head2 wait_for_map($window)
207 Thin wrapper around wait_for_event which waits for MAP_NOTIFY.
208 Make sure to include 'structure_notify' in the window’s event_mask attribute.
210 This function is called by C<open_window>, so in most cases, you don’t need to
211 call it on your own. If you need special setup of the window before mapping,
212 you might have to map it on your own and use this function:
214 my $window = open_window(dont_map => 1);
215 # Do something special with the window first
218 # Now map it and wait until it’s been mapped
220 wait_for_map($window);
225 my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
226 wait_for_event 4, sub {
227 $_[0]->{response_type} == MAP_NOTIFY and $_[0]->{window} == $id
231 =head2 wait_for_unmap($window)
233 Wrapper around C<wait_for_event> which waits for UNMAP_NOTIFY. Also calls
234 C<sync_with_i3> to make sure i3 also picked up and processed the UnmapNotify
237 my $ws = fresh_workspace;
238 my $window = open_window;
239 is_num_children($ws, 1, 'one window on workspace');
242 is_num_children($ws, 0, 'no more windows on this workspace');
247 # my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
248 wait_for_event 4, sub {
249 $_[0]->{response_type} == UNMAP_NOTIFY # and $_[0]->{window} == $id
254 =head2 open_window([ $args ])
256 Opens a new window (see C<X11::XCB::Window>), maps it, waits until it got mapped
257 and synchronizes with i3.
259 The following arguments can be passed:
265 The X11 window class (e.g. WINDOW_CLASS_INPUT_OUTPUT), not to be confused with
270 An arrayref with 4 members specifying the initial geometry (position and size)
271 of the window, e.g. C<< [ 0, 100, 70, 50 ] >> for a window appearing at x=0, y=100
272 with width=70 and height=50.
274 Note that this is entirely irrelevant for tiling windows.
276 =item background_color
278 The background pixel color of the window, formatted as "#rrggbb", like HTML
279 color codes (e.g. #c0c0c0). This is useful to tell windows apart when actually
280 watching the testcases.
284 An arrayref containing strings which describe the X11 event mask we use for that
285 window. The default is C<< [ 'structure_notify' ] >>.
289 The window’s C<_NET_WM_NAME> (UTF-8 window title). By default, this is "Window
290 n" with n being replaced by a counter to keep windows apart.
294 Set to a true value to avoid mapping the window (making it visible).
298 A coderef which is called before the window is mapped (unless C<dont_map> is
299 true). The freshly created C<$window> is passed as C<$_> and as the first
304 The default values are equivalent to this call:
307 class => WINDOW_CLASS_INPUT_OUTPUT
308 rect => [ 0, 0, 30, 30 ]
309 background_color => '#c0c0c0'
310 event_mask => [ 'structure_notify' ]
314 Usually, though, calls are simpler:
316 my $top_window = open_window;
318 To identify the resulting window object in i3 commands, use the id property:
320 my $top_window = open_window;
321 cmd '[id="' . $top_window->id . '"] kill';
325 my %args = @_ == 1 ? %{$_[0]} : @_;
327 my $dont_map = delete $args{dont_map};
328 my $before_map = delete $args{before_map};
330 $args{class} //= WINDOW_CLASS_INPUT_OUTPUT;
331 $args{rect} //= [ 0, 0, 30, 30 ];
332 $args{background_color} //= '#c0c0c0';
333 $args{event_mask} //= [ 'structure_notify' ];
334 $args{name} //= 'Window ' . counter_window();
336 my $window = $x->root->create_child(%args);
337 $window->add_hint('input');
340 # TODO: investigate why _create is not needed
342 $before_map->($window) for $window;
345 return $window if $dont_map;
348 wait_for_map($window);
350 # MapWindow is sent before i3 even starts rendering: the window is placed at
351 # temporary off-screen coordinates first, and x_push_changes() sends further
352 # X11 requests to set focus etc. Hence, we sync with i3 before continuing.
358 =head2 open_floating_window([ $args ])
360 Thin wrapper around open_window which sets window_type to
361 C<_NET_WM_WINDOW_TYPE_UTILITY> to make the window floating.
363 The arguments are the same as those of C<open_window>.
366 sub open_floating_window {
367 my %args = @_ == 1 ? %{$_[0]} : @_;
369 $args{window_type} = $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY');
371 return open_window(\%args);
377 my $reply = $i3->command('open')->recv;
378 return $reply->[0]->{id};
381 =head2 get_workspace_names()
383 Returns an arrayref containing the name of every workspace (regardless of its
384 output) which currently exists.
386 my $workspace_names = get_workspace_names;
387 is(scalar @$workspace_names, 3, 'three workspaces exist currently');
390 sub get_workspace_names {
391 my $i3 = i3(get_socket_path());
392 my $tree = $i3->get_tree->recv;
393 my @outputs = @{$tree->{nodes}};
395 for my $output (@outputs) {
396 next if $output->{name} eq '__i3';
397 # get the first CT_CON of each output
398 my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
399 @cons = (@cons, @{$content->{nodes}});
401 [ map { $_->{name} } @cons ]
404 =head2 get_unused_workspace
406 Returns a workspace name which has not yet been used. See also
407 C<fresh_workspace> which directly switches to an unused workspace.
409 my $ws = get_unused_workspace;
413 sub get_unused_workspace {
414 my @names = get_workspace_names();
416 do { $tmp = tmpnam() } while ((scalar grep { $_ eq $tmp } @names) > 0);
420 =head2 fresh_workspace([ $args ])
422 Switches to an unused workspace and returns the name of that workspace.
424 Optionally switches to the specified output first.
426 my $ws = fresh_workspace;
428 # Get a fresh workspace on the second output.
429 my $ws = fresh_workspace(output => 1);
432 sub fresh_workspace {
434 if (exists($args{output})) {
435 my $i3 = i3(get_socket_path());
436 my $tree = $i3->get_tree->recv;
437 my $output = first { $_->{name} eq "fake-$args{output}" }
439 die "BUG: Could not find output $args{output}" unless defined($output);
440 # Get the focused workspace on that output and switch to it.
441 my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
442 my $focused = $content->{focus}->[0];
443 my $workspace = first { $_->{id} == $focused } @{$content->{nodes}};
444 $workspace = $workspace->{name};
445 cmd("workspace $workspace");
448 my $unused = get_unused_workspace;
449 cmd("workspace $unused");
453 =head2 get_ws($workspace)
455 Returns the container (from the i3 layout tree) which represents C<$workspace>.
457 my $ws = fresh_workspace;
458 my $ws_con = get_ws($ws);
459 ok(!$ws_con->{urgent}, 'fresh workspace not marked urgent');
461 Here is an example which counts the number of urgent containers recursively,
462 starting from the workspace container:
467 my @children = (@{$con->{nodes}}, @{$con->{floating_nodes}});
468 my $urgent = grep { $_->{urgent} } @children;
469 $urgent += count_urgent($_) for @children;
472 my $urgent = count_urgent(get_ws($ws));
473 is($urgent, 3, "three urgent windows on workspace $ws");
479 my $i3 = i3(get_socket_path());
480 my $tree = $i3->get_tree->recv;
482 my @outputs = @{$tree->{nodes}};
484 for my $output (@outputs) {
485 # get the first CT_CON of each output
486 my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
487 @workspaces = (@workspaces, @{$content->{nodes}});
490 # as there can only be one workspace with this name, we can safely
491 # return the first entry
492 return first { $_->{name} eq $name } @workspaces;
495 =head2 get_ws_content($workspace)
497 Returns the content (== tree, starting from the node of a workspace)
498 of a workspace. If called in array context, also includes the focus
499 stack of the workspace.
501 my $nodes = get_ws_content($ws);
502 is(scalar @$nodes, 4, 'there are four containers at workspace-level');
504 Or, in array context:
506 my $window = open_window;
507 my ($nodes, $focus) = get_ws_content($ws);
508 is($focus->[0], $window->id, 'newly opened window focused');
510 Note that this function does not do recursion for you! It only returns the
511 containers B<on workspace level>. If you want to work with all containers (even
512 nested ones) on a workspace, you have to use recursion:
514 # NB: This function does not count floating windows
519 for my $con (@$nodes) {
520 $urgent++ if $con->{urgent};
521 $urgent += count_urgent($con->{nodes});
526 my $nodes = get_ws_content($ws);
527 my $urgent = count_urgent($nodes);
528 is($urgent, 3, "three urgent windows on workspace $ws");
530 If you also want to deal with floating windows, you have to use C<get_ws>
531 instead and access C<< ->{nodes} >> and C<< ->{floating_nodes} >> on your own.
536 my $con = get_ws($name);
537 return wantarray ? ($con->{nodes}, $con->{focus}) : $con->{nodes};
540 =head2 get_focused($workspace)
542 Returns the container ID of the currently focused container on C<$workspace>.
544 Note that the container ID is B<not> the X11 window ID, so comparing the result
545 of C<get_focused> with a window's C<< ->{id} >> property does B<not> work.
547 my $ws = fresh_workspace;
548 my $first_window = open_window;
549 my $first_id = get_focused();
551 my $second_window = open_window;
552 my $second_id = get_focused();
556 is(get_focused($ws), $first_id, 'second window focused');
561 my $con = get_ws($ws);
563 my @focused = @{$con->{focus}};
565 while (@focused > 0) {
567 last unless defined($con->{focus});
568 @focused = @{$con->{focus}};
569 my @cons = grep { $_->{id} == $lf } (@{$con->{nodes}}, @{$con->{'floating_nodes'}});
576 =head2 get_dock_clients([ $dockarea ])
578 Returns an array of all dock containers in C<$dockarea> (one of "top" or
579 "bottom"). If C<$dockarea> is not specified, returns an array of all dock
580 containers in any dockarea.
582 my @docked = get_dock_clients;
583 is(scalar @docked, 0, 'no dock clients yet');
586 sub get_dock_clients {
589 my $tree = i3(get_socket_path())->get_tree->recv;
590 my @outputs = @{$tree->{nodes}};
591 # Children of all dockareas
593 for my $output (@outputs) {
594 if (!defined($which)) {
595 @docked = (@docked, map { @{$_->{nodes}} }
596 grep { $_->{type} eq 'dockarea' }
597 @{$output->{nodes}});
598 } elsif ($which eq 'top') {
599 my $first = first { $_->{type} eq 'dockarea' } @{$output->{nodes}};
600 @docked = (@docked, @{$first->{nodes}}) if defined($first);
601 } elsif ($which eq 'bottom') {
602 my @matching = grep { $_->{type} eq 'dockarea' } @{$output->{nodes}};
603 my $last = $matching[-1];
604 @docked = (@docked, @{$last->{nodes}}) if defined($last);
612 Sends the specified command to i3 and returns the output.
614 my $ws = unused_workspace;
620 i3(get_socket_path())->command(@_)->recv
623 =head2 workspace_exists($workspace)
625 Returns true if C<$workspace> is the name of an existing workspace.
627 my $old_ws = focused_ws;
628 # switch away from where we currently are
631 ok(workspace_exists($old_ws), 'old workspace still exists');
634 sub workspace_exists {
636 (scalar grep { $_ eq $name } @{get_workspace_names()}) > 0;
641 Returns the name of the currently focused workspace.
644 is($ws, '1', 'i3 starts on workspace 1');
648 my $i3 = i3(get_socket_path());
649 my $tree = $i3->get_tree->recv;
650 my $focused = $tree->{focus}->[0];
651 my $output = first { $_->{id} == $focused } @{$tree->{nodes}};
652 my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
653 my $first = first { $_->{fullscreen_mode} == 1 } @{$content->{nodes}};
654 return $first->{name}
657 =head2 sync_with_i3([ $args ])
659 Sends an I3_SYNC ClientMessage with a random value to the root window.
660 i3 will reply with the same value, but, due to the order of events it
661 processes, only after all other events are done.
663 This can be used to ensure the results of a cmd 'focus left' are pushed to
664 X11 and that C<< $x->input_focus >> returns the correct value afterwards.
666 See also L<https://build.i3wm.org/docs/testsuite.html> for a longer explanation.
668 my $window = open_window;
669 $window->add_hint('urgency');
670 # Ensure i3 picked up the change
673 The only time when you need to use the C<no_cache> argument is when you just
674 killed your own X11 connection:
677 # We need to re-establish the X11 connection which we just killed :).
678 $x = i3test::X11->new;
679 sync_with_i3(no_cache => 1);
683 my %args = @_ == 1 ? %{$_[0]} : @_;
685 # Since we need a (mapped) window for receiving a ClientMessage, we create
686 # one on the first call of sync_with_i3. It will be re-used in all
688 if (!exists($args{window_id}) &&
689 (!defined($_sync_window) || exists($args{no_cache}))) {
690 $_sync_window = open_window(
691 rect => [ -15, -15, 10, 10 ],
692 override_redirect => 1,
697 my $window_id = delete $args{window_id};
698 $window_id //= $_sync_window->id;
700 my $root = $x->get_root_window();
701 # Generate a random number to identify this particular ClientMessage.
702 my $myrnd = int(rand(255)) + 1;
704 # Generate a ClientMessage, see xcb_client_message_t
705 my $msg = pack "CCSLLLLLLL",
706 CLIENT_MESSAGE, # response_type
709 $root, # destination window
710 $x->atom(name => 'I3_SYNC')->id,
712 $window_id, # data[0]: our own window id
713 $myrnd, # data[1]: a random value to identify the request
718 # Send it to the root window -- since i3 uses the SubstructureRedirect
719 # event mask, it will get the ClientMessage.
720 $x->send_event(0, $root, EVENT_MASK_SUBSTRUCTURE_REDIRECT, $msg);
722 return $myrnd if $args{dont_wait_for_event};
724 # now wait until the reply is here
725 return wait_for_event 4, sub {
728 return 0 unless $event->{response_type} == 161;
730 my ($win, $rnd) = unpack "LL", $event->{data};
731 return ($rnd == $myrnd);
735 =head2 exit_gracefully($pid, [ $socketpath ])
737 Tries to exit i3 gracefully (with the 'exit' cmd) or kills the PID if that fails.
739 If C<$socketpath> is not specified, C<get_socket_path()> will be called.
741 You only need to use this function if you have launched i3 on your own with
742 C<launch_with_config>. Otherwise, it will be automatically called when the
745 use i3test i3_autostart => 0;
746 my $pid = launch_with_config($config);
748 exit_gracefully($pid);
751 sub exit_gracefully {
752 my ($pid, $socketpath) = @_;
753 $socketpath ||= get_socket_path();
757 say "Exiting i3 cleanly...";
758 i3($socketpath)->command('exit')->recv;
764 or $tester->BAIL_OUT("could not kill i3: $!");
767 if ($socketpath =~ m,^/tmp/i3-test-socket-,) {
775 =head2 exit_forcefully($pid, [ $signal ])
777 Tries to exit i3 forcefully by sending a signal (defaults to SIGTERM).
779 You only need to use this function if you want to test signal handling
780 (in which case you must have launched i3 on your own with
781 C<launch_with_config>).
783 use i3test i3_autostart => 0;
784 my $pid = launch_with_config($config);
786 exit_forcefully($pid);
789 sub exit_forcefully {
790 my ($pid, $signal) = @_;
793 # Send the given signal to the i3 instance and wait for up to 10s
794 # for it to terminate.
796 or $tester->BAIL_OUT("could not kill i3: $!");
800 $status = waitpid $pid, WNOHANG;
806 } while ($status <= 0 && $timeout > 0);
810 or $tester->BAIL_OUT("could not kill i3: $!");
816 =head2 get_socket_path([ $cache ])
818 Gets the socket path from the C<I3_SOCKET_PATH> atom stored on the X11 root
819 window. After the first call, this function will return a cached version of the
820 socket path unless you specify a false value for C<$cache>.
822 my $i3 = i3(get_socket_path());
823 $i3->command('nop test example')->recv;
827 my $i3 = i3(get_socket_path(0));
830 sub get_socket_path {
834 if ($cache && defined($_cached_socket_path)) {
835 return $_cached_socket_path;
837 my $socketpath = i3test::Util::get_socket_path($x);
838 $_cached_socket_path = $socketpath;
842 =head2 launch_with_config($config, [ $args ])
844 Launches a new i3 process with C<$config> as configuration file. Useful for
845 tests which test specific config file directives.
847 use i3test i3_autostart => 0;
850 # i3 config file (v4)
851 for_window [class="borderless"] border none
852 for_window [title="special borderless title"] border none
855 my $pid = launch_with_config($config);
859 exit_gracefully($pid);
862 sub launch_with_config {
863 my ($config, %args) = @_;
865 $tmp_socket_path = "/tmp/nested-$ENV{DISPLAY}";
867 $args{dont_create_temp_dir} //= 0;
868 $args{validate_config} //= 0;
870 my ($fh, $tmpfile) = tempfile("i3-cfg-for-$ENV{TESTNAME}-XXXXX", UNLINK => 1);
872 say $fh "ipc-socket $tmp_socket_path"
873 unless $args{dont_add_socket_path};
875 if ($config ne '-default') {
878 open(my $conf_fh, '<', '@abs_top_srcdir@/testcases/i3-test.config')
879 or $tester->BAIL_OUT("could not open default config: $!");
881 say $fh scalar <$conf_fh>;
886 my $cv = AnyEvent->condvar;
887 $i3_pid = activate_i3(
888 unix_socket_path => "$tmp_socket_path-activation",
889 display => $ENV{DISPLAY},
890 configfile => $tmpfile,
891 outdir => $ENV{OUTDIR},
892 testname => $ENV{TESTNAME},
893 valgrind => $ENV{VALGRIND},
894 strace => $ENV{STRACE},
895 xtrace => $ENV{XTRACE},
896 restart => $ENV{RESTART},
898 dont_create_temp_dir => $args{dont_create_temp_dir},
899 validate_config => $args{validate_config},
900 inject_randr15 => $args{inject_randr15},
901 inject_randr15_outputinfo => $args{inject_randr15_outputinfo},
904 # If we called i3 with -C, we wait for it to exit and then return as
905 # there's nothing else we need to do.
906 if ($args{validate_config}) {
910 # We need this since exit_gracefully will not be called in this case.
913 return ${^CHILD_ERROR_NATIVE};
916 # force update of the cached socket path in lib/i3test
917 # as soon as i3 has started
918 $cv->cb(sub { get_socket_path(0) });
920 return $cv if $args{dont_block};
922 # blockingly wait until i3 is ready
930 Returns the content of the log file for the current test.
934 my $logfile = "$ENV{OUTDIR}/i3-log-for-$ENV{TESTNAME}";
935 return slurp($logfile);
938 =head2 kill_all_windows
940 Kills all windows to clean up between tests.
943 sub kill_all_windows {
944 # Sync in case not all windows are managed by i3 just yet.
946 cmd '[title=".*"] kill';
949 =head2 events_for($subscribecb, [ $rettype ], [ $eventcbs ])
951 Helper function which returns an array containing all events of type $rettype
952 which were generated by i3 while $subscribecb was running.
954 Set $eventcbs to subscribe to multiple event types and/or perform your own event
959 my ($subscribecb, $rettype, $eventcbs) = @_;
963 if (defined($rettype)) {
964 $eventcbs->{$rettype} = sub { push @events, shift };
966 my $subscribed = AnyEvent->condvar;
967 my $flushed = AnyEvent->condvar;
968 $eventcbs->{tick} = sub {
970 if ($event->{first}) {
971 $subscribed->send($event);
973 $flushed->send($event);
976 my $i3 = i3(get_socket_path(0));
978 $i3->subscribe($eventcbs)->recv;
980 # Subscription established, run the callback.
982 # Now generate a tick event, which we know we’ll receive (and at which point
983 # all other events have been received).
984 my $nonce = int(rand(255)) + 1;
985 $i3->send_tick($nonce);
987 my $tick = $flushed->recv;
988 $tester->is_eq($tick->{payload}, $nonce, 'tick nonce received');
992 =head2 listen_for_binding($cb)
994 Helper function to evaluate whether sending KeyPress/KeyRelease events via XTEST
995 triggers an i3 key binding or not. Expects key bindings to be configured in the
996 form “bindsym <binding> nop <binding>”, e.g. “bindsym Mod4+Return nop
999 is(listen_for_binding(
1001 xtest_key_press(133); # Super_L
1002 xtest_key_press(36); # Return
1003 xtest_key_release(36); # Return
1004 xtest_key_release(133); # Super_L
1009 'triggered the "Mod4+Return" keybinding');
1013 sub listen_for_binding {
1015 my $triggered = AnyEvent->condvar;
1016 my @events = events_for(
1020 $tester->is_eq(scalar @events, 1, 'Received precisely one event');
1021 $tester->is_eq($events[0]->{change}, 'run', 'change is "run"');
1022 # We look at the command (which is “nop <binding>”) because that is easier
1023 # than re-assembling the string representation of $event->{binding}.
1024 my $command = $events[0]->{binding}->{command};
1025 $command =~ s/^nop //g;
1031 Michael Stapelberg <michael@i3wm.org>
1035 package i3test::X11;
1036 use parent 'X11::XCB::Connection';
1040 i3test::sync_with_i3();
1042 return $self->SUPER::input_focus(@_);