6800524f2e
So far, this was blessed for internal use only (by virtue of not being in the documentation), but we want to expose it for the stored layouts.
888 lines
23 KiB
Perl
888 lines
23 KiB
Perl
package i3test;
|
||
# vim:ts=4:sw=4:expandtab
|
||
use strict; use warnings;
|
||
|
||
use File::Temp qw(tmpnam tempfile tempdir);
|
||
use Test::Builder;
|
||
use X11::XCB::Rect;
|
||
use X11::XCB::Window;
|
||
use X11::XCB qw(:all);
|
||
use AnyEvent::I3;
|
||
use List::Util qw(first);
|
||
use Time::HiRes qw(sleep);
|
||
use Cwd qw(abs_path);
|
||
use Scalar::Util qw(blessed);
|
||
use SocketActivation;
|
||
|
||
use v5.10;
|
||
|
||
# preload
|
||
use Test::More ();
|
||
use Data::Dumper ();
|
||
|
||
use Exporter ();
|
||
our @EXPORT = qw(
|
||
get_workspace_names
|
||
get_unused_workspace
|
||
fresh_workspace
|
||
get_ws_content
|
||
get_ws
|
||
get_focused
|
||
open_empty_con
|
||
open_window
|
||
open_floating_window
|
||
get_dock_clients
|
||
cmd
|
||
sync_with_i3
|
||
exit_gracefully
|
||
workspace_exists
|
||
focused_ws
|
||
get_socket_path
|
||
launch_with_config
|
||
wait_for_event
|
||
wait_for_map
|
||
wait_for_unmap
|
||
$x
|
||
);
|
||
|
||
=head1 NAME
|
||
|
||
i3test - Testcase setup module
|
||
|
||
=encoding utf-8
|
||
|
||
=head1 SYNOPSIS
|
||
|
||
use i3test;
|
||
|
||
my $ws = fresh_workspace;
|
||
is_num_children($ws, 0, 'no containers on this workspace yet');
|
||
cmd 'open';
|
||
is_num_children($ws, 1, 'one container after "open"');
|
||
|
||
done_testing;
|
||
|
||
=head1 DESCRIPTION
|
||
|
||
This module is used in every i3 testcase and takes care of automatically
|
||
starting i3 before any test instructions run. It also saves you typing of lots
|
||
of boilerplate in every test file.
|
||
|
||
|
||
i3test automatically "use"s C<Test::More>, C<Data::Dumper>, C<AnyEvent::I3>,
|
||
C<Time::HiRes>’s C<sleep> and C<i3test::Test> so that all of them are available
|
||
to you in your testcase.
|
||
|
||
See also C<i3test::Test> (L<http://build.i3wm.org/docs/lib-i3test-test.html>)
|
||
which provides additional test instructions (like C<ok> or C<is>).
|
||
|
||
=cut
|
||
|
||
my $tester = Test::Builder->new();
|
||
my $_cached_socket_path = undef;
|
||
my $_sync_window = undef;
|
||
my $tmp_socket_path = undef;
|
||
|
||
our $x;
|
||
|
||
BEGIN {
|
||
my $window_count = 0;
|
||
sub counter_window {
|
||
return $window_count++;
|
||
}
|
||
}
|
||
|
||
my $i3_pid;
|
||
my $i3_autostart;
|
||
|
||
END {
|
||
|
||
# testcases which start i3 manually should always call exit_gracefully
|
||
# on their own. Let’s see, whether they really did.
|
||
if (! $i3_autostart) {
|
||
return unless $i3_pid;
|
||
|
||
$tester->ok(undef, 'testcase called exit_gracefully()');
|
||
}
|
||
|
||
# don't trigger SIGCHLD handler
|
||
local $SIG{CHLD};
|
||
|
||
# From perldoc -v '$?':
|
||
# Inside an "END" subroutine $? contains the value
|
||
# that is going to be given to "exit()".
|
||
#
|
||
# Since waitpid sets $?, we need to localize it,
|
||
# otherwise TAP would be misinterpreted our return status
|
||
local $?;
|
||
|
||
# When measuring code coverage, try to exit i3 cleanly (otherwise, .gcda
|
||
# files are not written)
|
||
if ($ENV{COVERAGE} || $ENV{VALGRIND}) {
|
||
exit_gracefully($i3_pid, "/tmp/nested-$ENV{DISPLAY}");
|
||
|
||
} else {
|
||
kill(9, $i3_pid)
|
||
or $tester->BAIL_OUT("could not kill i3");
|
||
|
||
waitpid $i3_pid, 0;
|
||
}
|
||
}
|
||
|
||
sub import {
|
||
my ($class, %args) = @_;
|
||
my $pkg = caller;
|
||
|
||
$i3_autostart = delete($args{i3_autostart}) // 1;
|
||
|
||
my $cv = launch_with_config('-default', dont_block => 1)
|
||
if $i3_autostart;
|
||
|
||
my $test_more_args = '';
|
||
$test_more_args = join(' ', 'qw(', %args, ')') if keys %args;
|
||
local $@;
|
||
eval << "__";
|
||
package $pkg;
|
||
use Test::More $test_more_args;
|
||
use Data::Dumper;
|
||
use AnyEvent::I3;
|
||
use Time::HiRes qw(sleep);
|
||
use i3test::Test;
|
||
__
|
||
$tester->BAIL_OUT("$@") if $@;
|
||
feature->import(":5.10");
|
||
strict->import;
|
||
warnings->import;
|
||
|
||
$x ||= i3test::X11->new;
|
||
# set the pointer to a predictable position in case a previous test has
|
||
# disturbed it
|
||
$x->root->warp_pointer(0, 0);
|
||
$cv->recv if $i3_autostart;
|
||
|
||
@_ = ($class);
|
||
goto \&Exporter::import;
|
||
}
|
||
|
||
=head1 EXPORT
|
||
|
||
=head2 wait_for_event($timeout, $callback)
|
||
|
||
Waits for the next event and calls the given callback for every event to
|
||
determine if this is the event we are waiting for.
|
||
|
||
Can be used to wait until a window is mapped, until a ClientMessage is
|
||
received, etc.
|
||
|
||
wait_for_event 0.25, sub { $_[0]->{response_type} == MAP_NOTIFY };
|
||
|
||
=cut
|
||
sub wait_for_event {
|
||
my ($timeout, $cb) = @_;
|
||
|
||
my $cv = AE::cv;
|
||
|
||
$x->flush;
|
||
|
||
# unfortunately, there is no constant for this
|
||
my $ae_read = 0;
|
||
|
||
my $guard = AE::io $x->get_file_descriptor, $ae_read, sub {
|
||
while (defined(my $event = $x->poll_for_event)) {
|
||
if ($cb->($event)) {
|
||
$cv->send(1);
|
||
last;
|
||
}
|
||
}
|
||
};
|
||
|
||
# Trigger timeout after $timeout seconds (can be fractional)
|
||
my $t = AE::timer $timeout, 0, sub { warn "timeout ($timeout secs)"; $cv->send(0) };
|
||
|
||
my $result = $cv->recv;
|
||
undef $t;
|
||
undef $guard;
|
||
return $result;
|
||
}
|
||
|
||
=head2 wait_for_map($window)
|
||
|
||
Thin wrapper around wait_for_event which waits for MAP_NOTIFY.
|
||
Make sure to include 'structure_notify' in the window’s event_mask attribute.
|
||
|
||
This function is called by C<open_window>, so in most cases, you don’t need to
|
||
call it on your own. If you need special setup of the window before mapping,
|
||
you might have to map it on your own and use this function:
|
||
|
||
my $window = open_window(dont_map => 1);
|
||
# Do something special with the window first
|
||
# …
|
||
|
||
# Now map it and wait until it’s been mapped
|
||
$window->map;
|
||
wait_for_map($window);
|
||
|
||
=cut
|
||
sub wait_for_map {
|
||
my ($win) = @_;
|
||
my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
|
||
wait_for_event 2, sub {
|
||
$_[0]->{response_type} == MAP_NOTIFY and $_[0]->{window} == $id
|
||
};
|
||
}
|
||
|
||
=head2 wait_for_unmap($window)
|
||
|
||
Wrapper around C<wait_for_event> which waits for UNMAP_NOTIFY. Also calls
|
||
C<sync_with_i3> to make sure i3 also picked up and processed the UnmapNotify
|
||
event.
|
||
|
||
my $ws = fresh_workspace;
|
||
my $window = open_window;
|
||
is_num_children($ws, 1, 'one window on workspace');
|
||
$window->unmap;
|
||
wait_for_unmap;
|
||
is_num_children($ws, 0, 'no more windows on this workspace');
|
||
|
||
=cut
|
||
sub wait_for_unmap {
|
||
my ($win) = @_;
|
||
# my $id = (blessed($win) && $win->isa('X11::XCB::Window')) ? $win->id : $win;
|
||
wait_for_event 2, sub {
|
||
$_[0]->{response_type} == UNMAP_NOTIFY # and $_[0]->{window} == $id
|
||
};
|
||
sync_with_i3();
|
||
}
|
||
|
||
=head2 open_window([ $args ])
|
||
|
||
Opens a new window (see C<X11::XCB::Window>), maps it, waits until it got mapped
|
||
and synchronizes with i3.
|
||
|
||
The following arguments can be passed:
|
||
|
||
=over 4
|
||
|
||
=item class
|
||
|
||
The X11 window class (e.g. WINDOW_CLASS_INPUT_OUTPUT), not to be confused with
|
||
the WM_CLASS!
|
||
|
||
=item rect
|
||
|
||
An arrayref with 4 members specifying the initial geometry (position and size)
|
||
of the window, e.g. C<< [ 0, 100, 70, 50 ] >> for a window appearing at x=0, y=100
|
||
with width=70 and height=50.
|
||
|
||
Note that this is entirely irrelevant for tiling windows.
|
||
|
||
=item background_color
|
||
|
||
The background pixel color of the window, formatted as "#rrggbb", like HTML
|
||
color codes (e.g. #c0c0c0). This is useful to tell windows apart when actually
|
||
watching the testcases.
|
||
|
||
=item event_mask
|
||
|
||
An arrayref containing strings which describe the X11 event mask we use for that
|
||
window. The default is C<< [ 'structure_notify' ] >>.
|
||
|
||
=item name
|
||
|
||
The window’s C<_NET_WM_NAME> (UTF-8 window title). By default, this is "Window
|
||
n" with n being replaced by a counter to keep windows apart.
|
||
|
||
=item dont_map
|
||
|
||
Set to a true value to avoid mapping the window (making it visible).
|
||
|
||
=item before_map
|
||
|
||
A coderef which is called before the window is mapped (unless C<dont_map> is
|
||
true). The freshly created C<$window> is passed as C<$_> and as the first
|
||
argument.
|
||
|
||
=back
|
||
|
||
The default values are equivalent to this call:
|
||
|
||
open_window(
|
||
class => WINDOW_CLASS_INPUT_OUTPUT
|
||
rect => [ 0, 0, 30, 30 ]
|
||
background_color => '#c0c0c0'
|
||
event_mask => [ 'structure_notify' ]
|
||
name => 'Window <n>'
|
||
);
|
||
|
||
Usually, though, calls are simpler:
|
||
|
||
my $top_window = open_window;
|
||
|
||
To identify the resulting window object in i3 commands, use the id property:
|
||
|
||
my $top_window = open_window;
|
||
cmd '[id="' . $top_window->id . '"] kill';
|
||
|
||
=cut
|
||
sub open_window {
|
||
my %args = @_ == 1 ? %{$_[0]} : @_;
|
||
|
||
my $dont_map = delete $args{dont_map};
|
||
my $before_map = delete $args{before_map};
|
||
|
||
$args{class} //= WINDOW_CLASS_INPUT_OUTPUT;
|
||
$args{rect} //= [ 0, 0, 30, 30 ];
|
||
$args{background_color} //= '#c0c0c0';
|
||
$args{event_mask} //= [ 'structure_notify' ];
|
||
$args{name} //= 'Window ' . counter_window();
|
||
|
||
my $window = $x->root->create_child(%args);
|
||
|
||
if ($before_map) {
|
||
# TODO: investigate why _create is not needed
|
||
$window->_create;
|
||
$before_map->($window) for $window;
|
||
}
|
||
|
||
return $window if $dont_map;
|
||
|
||
$window->map;
|
||
wait_for_map($window);
|
||
return $window;
|
||
}
|
||
|
||
=head2 open_floating_window([ $args ])
|
||
|
||
Thin wrapper around open_window which sets window_type to
|
||
C<_NET_WM_WINDOW_TYPE_UTILITY> to make the window floating.
|
||
|
||
The arguments are the same as those of C<open_window>.
|
||
|
||
=cut
|
||
sub open_floating_window {
|
||
my %args = @_ == 1 ? %{$_[0]} : @_;
|
||
|
||
$args{window_type} = $x->atom(name => '_NET_WM_WINDOW_TYPE_UTILITY');
|
||
|
||
return open_window(\%args);
|
||
}
|
||
|
||
sub open_empty_con {
|
||
my ($i3) = @_;
|
||
|
||
my $reply = $i3->command('open')->recv;
|
||
return $reply->[0]->{id};
|
||
}
|
||
|
||
=head2 get_workspace_names()
|
||
|
||
Returns an arrayref containing the name of every workspace (regardless of its
|
||
output) which currently exists.
|
||
|
||
my $workspace_names = get_workspace_names;
|
||
is(scalar @$workspace_names, 3, 'three workspaces exist currently');
|
||
|
||
=cut
|
||
sub get_workspace_names {
|
||
my $i3 = i3(get_socket_path());
|
||
my $tree = $i3->get_tree->recv;
|
||
my @outputs = @{$tree->{nodes}};
|
||
my @cons;
|
||
for my $output (@outputs) {
|
||
next if $output->{name} eq '__i3';
|
||
# get the first CT_CON of each output
|
||
my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
|
||
@cons = (@cons, @{$content->{nodes}});
|
||
}
|
||
[ map { $_->{name} } @cons ]
|
||
}
|
||
|
||
=head2 get_unused_workspace
|
||
|
||
Returns a workspace name which has not yet been used. See also
|
||
C<fresh_workspace> which directly switches to an unused workspace.
|
||
|
||
my $ws = get_unused_workspace;
|
||
cmd "workspace $ws";
|
||
|
||
=cut
|
||
sub get_unused_workspace {
|
||
my @names = get_workspace_names();
|
||
my $tmp;
|
||
do { $tmp = tmpnam() } while ((scalar grep { $_ eq $tmp } @names) > 0);
|
||
$tmp
|
||
}
|
||
|
||
=head2 fresh_workspace([ $args ])
|
||
|
||
Switches to an unused workspace and returns the name of that workspace.
|
||
|
||
Optionally switches to the specified output first.
|
||
|
||
my $ws = fresh_workspace;
|
||
|
||
# Get a fresh workspace on the second output.
|
||
my $ws = fresh_workspace(output => 1);
|
||
|
||
=cut
|
||
sub fresh_workspace {
|
||
my %args = @_;
|
||
if (exists($args{output})) {
|
||
my $i3 = i3(get_socket_path());
|
||
my $tree = $i3->get_tree->recv;
|
||
my $output = first { $_->{name} eq "fake-$args{output}" }
|
||
@{$tree->{nodes}};
|
||
die "BUG: Could not find output $args{output}" unless defined($output);
|
||
# Get the focused workspace on that output and switch to it.
|
||
my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
|
||
my $focused = $content->{focus}->[0];
|
||
my $workspace = first { $_->{id} == $focused } @{$content->{nodes}};
|
||
$workspace = $workspace->{name};
|
||
cmd("workspace $workspace");
|
||
}
|
||
|
||
my $unused = get_unused_workspace;
|
||
cmd("workspace $unused");
|
||
$unused
|
||
}
|
||
|
||
=head2 get_ws($workspace)
|
||
|
||
Returns the container (from the i3 layout tree) which represents C<$workspace>.
|
||
|
||
my $ws = fresh_workspace;
|
||
my $ws_con = get_ws($ws);
|
||
ok(!$ws_con->{urgent}, 'fresh workspace not marked urgent');
|
||
|
||
Here is an example which counts the number of urgent containers recursively,
|
||
starting from the workspace container:
|
||
|
||
sub count_urgent {
|
||
my ($con) = @_;
|
||
|
||
my @children = (@{$con->{nodes}}, @{$con->{floating_nodes}});
|
||
my $urgent = grep { $_->{urgent} } @children;
|
||
$urgent += count_urgent($_) for @children;
|
||
return $urgent;
|
||
}
|
||
my $urgent = count_urgent(get_ws($ws));
|
||
is($urgent, 3, "three urgent windows on workspace $ws");
|
||
|
||
|
||
=cut
|
||
sub get_ws {
|
||
my ($name) = @_;
|
||
my $i3 = i3(get_socket_path());
|
||
my $tree = $i3->get_tree->recv;
|
||
|
||
my @outputs = @{$tree->{nodes}};
|
||
my @workspaces;
|
||
for my $output (@outputs) {
|
||
# get the first CT_CON of each output
|
||
my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
|
||
@workspaces = (@workspaces, @{$content->{nodes}});
|
||
}
|
||
|
||
# as there can only be one workspace with this name, we can safely
|
||
# return the first entry
|
||
return first { $_->{name} eq $name } @workspaces;
|
||
}
|
||
|
||
=head2 get_ws_content($workspace)
|
||
|
||
Returns the content (== tree, starting from the node of a workspace)
|
||
of a workspace. If called in array context, also includes the focus
|
||
stack of the workspace.
|
||
|
||
my $nodes = get_ws_content($ws);
|
||
is(scalar @$nodes, 4, 'there are four containers at workspace-level');
|
||
|
||
Or, in array context:
|
||
|
||
my $window = open_window;
|
||
my ($nodes, $focus) = get_ws_content($ws);
|
||
is($focus->[0], $window->id, 'newly opened window focused');
|
||
|
||
Note that this function does not do recursion for you! It only returns the
|
||
containers B<on workspace level>. If you want to work with all containers (even
|
||
nested ones) on a workspace, you have to use recursion:
|
||
|
||
# NB: This function does not count floating windows
|
||
sub count_urgent {
|
||
my ($nodes) = @_;
|
||
|
||
my $urgent = 0;
|
||
for my $con (@$nodes) {
|
||
$urgent++ if $con->{urgent};
|
||
$urgent += count_urgent($con->{nodes});
|
||
}
|
||
|
||
return $urgent;
|
||
}
|
||
my $nodes = get_ws_content($ws);
|
||
my $urgent = count_urgent($nodes);
|
||
is($urgent, 3, "three urgent windows on workspace $ws");
|
||
|
||
If you also want to deal with floating windows, you have to use C<get_ws>
|
||
instead and access C<< ->{nodes} >> and C<< ->{floating_nodes} >> on your own.
|
||
|
||
=cut
|
||
sub get_ws_content {
|
||
my ($name) = @_;
|
||
my $con = get_ws($name);
|
||
return wantarray ? ($con->{nodes}, $con->{focus}) : $con->{nodes};
|
||
}
|
||
|
||
=head2 get_focused($workspace)
|
||
|
||
Returns the container ID of the currently focused container on C<$workspace>.
|
||
|
||
Note that the container ID is B<not> the X11 window ID, so comparing the result
|
||
of C<get_focused> with a window's C<< ->{id} >> property does B<not> work.
|
||
|
||
my $ws = fresh_workspace;
|
||
my $first_window = open_window;
|
||
my $first_id = get_focused();
|
||
|
||
my $second_window = open_window;
|
||
my $second_id = get_focused();
|
||
|
||
cmd 'focus left';
|
||
|
||
is(get_focused($ws), $first_id, 'second window focused');
|
||
|
||
=cut
|
||
sub get_focused {
|
||
my ($ws) = @_;
|
||
my $con = get_ws($ws);
|
||
|
||
my @focused = @{$con->{focus}};
|
||
my $lf;
|
||
while (@focused > 0) {
|
||
$lf = $focused[0];
|
||
last unless defined($con->{focus});
|
||
@focused = @{$con->{focus}};
|
||
my @cons = grep { $_->{id} == $lf } (@{$con->{nodes}}, @{$con->{'floating_nodes'}});
|
||
$con = $cons[0];
|
||
}
|
||
|
||
return $lf;
|
||
}
|
||
|
||
=head2 get_dock_clients([ $dockarea ])
|
||
|
||
Returns an array of all dock containers in C<$dockarea> (one of "top" or
|
||
"bottom"). If C<$dockarea> is not specified, returns an array of all dock
|
||
containers in any dockarea.
|
||
|
||
my @docked = get_dock_clients;
|
||
is(scalar @docked, 0, 'no dock clients yet');
|
||
|
||
=cut
|
||
sub get_dock_clients {
|
||
my $which = shift;
|
||
|
||
my $tree = i3(get_socket_path())->get_tree->recv;
|
||
my @outputs = @{$tree->{nodes}};
|
||
# Children of all dockareas
|
||
my @docked;
|
||
for my $output (@outputs) {
|
||
if (!defined($which)) {
|
||
@docked = (@docked, map { @{$_->{nodes}} }
|
||
grep { $_->{type} eq 'dockarea' }
|
||
@{$output->{nodes}});
|
||
} elsif ($which eq 'top') {
|
||
my $first = first { $_->{type} eq 'dockarea' } @{$output->{nodes}};
|
||
@docked = (@docked, @{$first->{nodes}}) if defined($first);
|
||
} elsif ($which eq 'bottom') {
|
||
my @matching = grep { $_->{type} eq 'dockarea' } @{$output->{nodes}};
|
||
my $last = $matching[-1];
|
||
@docked = (@docked, @{$last->{nodes}}) if defined($last);
|
||
}
|
||
}
|
||
return @docked;
|
||
}
|
||
|
||
=head2 cmd($command)
|
||
|
||
Sends the specified command to i3.
|
||
|
||
my $ws = unused_workspace;
|
||
cmd "workspace $ws";
|
||
cmd 'focus right';
|
||
|
||
=cut
|
||
sub cmd {
|
||
i3(get_socket_path())->command(@_)->recv
|
||
}
|
||
|
||
=head2 workspace_exists($workspace)
|
||
|
||
Returns true if C<$workspace> is the name of an existing workspace.
|
||
|
||
my $old_ws = focused_ws;
|
||
# switch away from where we currently are
|
||
fresh_workspace;
|
||
|
||
ok(workspace_exists($old_ws), 'old workspace still exists');
|
||
|
||
=cut
|
||
sub workspace_exists {
|
||
my ($name) = @_;
|
||
(scalar grep { $_ eq $name } @{get_workspace_names()}) > 0;
|
||
}
|
||
|
||
=head2 focused_ws
|
||
|
||
Returns the name of the currently focused workspace.
|
||
|
||
my $ws = focused_ws;
|
||
is($ws, '1', 'i3 starts on workspace 1');
|
||
|
||
=cut
|
||
sub focused_ws {
|
||
my $i3 = i3(get_socket_path());
|
||
my $tree = $i3->get_tree->recv;
|
||
my $focused = $tree->{focus}->[0];
|
||
my $output = first { $_->{id} == $focused } @{$tree->{nodes}};
|
||
my $content = first { $_->{type} eq 'con' } @{$output->{nodes}};
|
||
my $first = first { $_->{fullscreen_mode} == 1 } @{$content->{nodes}};
|
||
return $first->{name}
|
||
}
|
||
|
||
=head2 sync_with_i3([ $args ])
|
||
|
||
Sends an I3_SYNC ClientMessage with a random value to the root window.
|
||
i3 will reply with the same value, but, due to the order of events it
|
||
processes, only after all other events are done.
|
||
|
||
This can be used to ensure the results of a cmd 'focus left' are pushed to
|
||
X11 and that C<< $x->input_focus >> returns the correct value afterwards.
|
||
|
||
See also L<http://build.i3wm.org/docs/testsuite.html> for a longer explanation.
|
||
|
||
my $window = open_window;
|
||
$window->add_hint('urgency');
|
||
# Ensure i3 picked up the change
|
||
sync_with_i3;
|
||
|
||
The only time when you need to use the C<no_cache> argument is when you just
|
||
killed your own X11 connection:
|
||
|
||
cmd 'kill client';
|
||
# We need to re-establish the X11 connection which we just killed :).
|
||
$x = i3test::X11->new;
|
||
sync_with_i3(no_cache => 1);
|
||
|
||
=cut
|
||
sub sync_with_i3 {
|
||
my %args = @_ == 1 ? %{$_[0]} : @_;
|
||
|
||
# Since we need a (mapped) window for receiving a ClientMessage, we create
|
||
# one on the first call of sync_with_i3. It will be re-used in all
|
||
# subsequent calls.
|
||
if (!exists($args{window_id}) &&
|
||
(!defined($_sync_window) || exists($args{no_cache}))) {
|
||
$_sync_window = open_window(
|
||
rect => [ -15, -15, 10, 10 ],
|
||
override_redirect => 1,
|
||
);
|
||
}
|
||
|
||
my $window_id = delete $args{window_id};
|
||
$window_id //= $_sync_window->id;
|
||
|
||
my $root = $x->get_root_window();
|
||
# Generate a random number to identify this particular ClientMessage.
|
||
my $myrnd = int(rand(255)) + 1;
|
||
|
||
# Generate a ClientMessage, see xcb_client_message_t
|
||
my $msg = pack "CCSLLLLLLL",
|
||
CLIENT_MESSAGE, # response_type
|
||
32, # format
|
||
0, # sequence
|
||
$root, # destination window
|
||
$x->atom(name => 'I3_SYNC')->id,
|
||
|
||
$window_id, # data[0]: our own window id
|
||
$myrnd, # data[1]: a random value to identify the request
|
||
0,
|
||
0,
|
||
0;
|
||
|
||
# Send it to the root window -- since i3 uses the SubstructureRedirect
|
||
# event mask, it will get the ClientMessage.
|
||
$x->send_event(0, $root, EVENT_MASK_SUBSTRUCTURE_REDIRECT, $msg);
|
||
|
||
# now wait until the reply is here
|
||
return wait_for_event 2, sub {
|
||
my ($event) = @_;
|
||
# TODO: const
|
||
return 0 unless $event->{response_type} == 161;
|
||
|
||
my ($win, $rnd) = unpack "LL", $event->{data};
|
||
return ($rnd == $myrnd);
|
||
};
|
||
}
|
||
|
||
=head2 exit_gracefully($pid, [ $socketpath ])
|
||
|
||
Tries to exit i3 gracefully (with the 'exit' cmd) or kills the PID if that fails.
|
||
|
||
If C<$socketpath> is not specified, C<get_socket_path()> will be called.
|
||
|
||
You only need to use this function if you have launched i3 on your own with
|
||
C<launch_with_config>. Otherwise, it will be automatically called when the
|
||
testcase ends.
|
||
|
||
use i3test i3_autostart => 0;
|
||
my $pid = launch_with_config($config);
|
||
# …
|
||
exit_gracefully($pid);
|
||
|
||
=cut
|
||
sub exit_gracefully {
|
||
my ($pid, $socketpath) = @_;
|
||
$socketpath ||= get_socket_path();
|
||
|
||
my $exited = 0;
|
||
eval {
|
||
say "Exiting i3 cleanly...";
|
||
i3($socketpath)->command('exit')->recv;
|
||
$exited = 1;
|
||
};
|
||
|
||
if (!$exited) {
|
||
kill(9, $pid)
|
||
or $tester->BAIL_OUT("could not kill i3");
|
||
}
|
||
|
||
if ($socketpath =~ m,^/tmp/i3-test-socket-,) {
|
||
unlink($socketpath);
|
||
}
|
||
|
||
waitpid $pid, 0;
|
||
undef $i3_pid;
|
||
}
|
||
|
||
=head2 get_socket_path([ $cache ])
|
||
|
||
Gets the socket path from the C<I3_SOCKET_PATH> atom stored on the X11 root
|
||
window. After the first call, this function will return a cached version of the
|
||
socket path unless you specify a false value for C<$cache>.
|
||
|
||
my $i3 = i3(get_socket_path());
|
||
$i3->command('nop test example')->recv;
|
||
|
||
To avoid caching:
|
||
|
||
my $i3 = i3(get_socket_path(0));
|
||
|
||
=cut
|
||
sub get_socket_path {
|
||
my ($cache) = @_;
|
||
$cache ||= 1;
|
||
|
||
if ($cache && defined($_cached_socket_path)) {
|
||
return $_cached_socket_path;
|
||
}
|
||
|
||
my $atom = $x->atom(name => 'I3_SOCKET_PATH');
|
||
my $cookie = $x->get_property(0, $x->get_root_window(), $atom->id, GET_PROPERTY_TYPE_ANY, 0, 256);
|
||
my $reply = $x->get_property_reply($cookie->{sequence});
|
||
my $socketpath = $reply->{value};
|
||
if ($socketpath eq "/tmp/nested-$ENV{DISPLAY}") {
|
||
$socketpath .= '-activation';
|
||
}
|
||
$_cached_socket_path = $socketpath;
|
||
return $socketpath;
|
||
}
|
||
|
||
=head2 launch_with_config($config, [ $args ])
|
||
|
||
Launches a new i3 process with C<$config> as configuration file. Useful for
|
||
tests which test specific config file directives.
|
||
|
||
use i3test i3_autostart => 0;
|
||
|
||
my $config = <<EOT;
|
||
# i3 config file (v4)
|
||
for_window [class="borderless"] border none
|
||
for_window [title="special borderless title"] border none
|
||
EOT
|
||
|
||
my $pid = launch_with_config($config);
|
||
|
||
# …
|
||
|
||
exit_gracefully($pid);
|
||
|
||
=cut
|
||
sub launch_with_config {
|
||
my ($config, %args) = @_;
|
||
|
||
$tmp_socket_path = "/tmp/nested-$ENV{DISPLAY}";
|
||
|
||
$args{dont_create_temp_dir} //= 0;
|
||
|
||
my ($fh, $tmpfile) = tempfile("i3-cfg-for-$ENV{TESTNAME}-XXXXX", UNLINK => 1);
|
||
|
||
if ($config ne '-default') {
|
||
say $fh $config;
|
||
} else {
|
||
open(my $conf_fh, '<', './i3-test.config')
|
||
or $tester->BAIL_OUT("could not open default config: $!");
|
||
local $/;
|
||
say $fh scalar <$conf_fh>;
|
||
}
|
||
|
||
say $fh "ipc-socket $tmp_socket_path"
|
||
unless $args{dont_add_socket_path};
|
||
|
||
close($fh);
|
||
|
||
my $cv = AnyEvent->condvar;
|
||
$i3_pid = activate_i3(
|
||
unix_socket_path => "$tmp_socket_path-activation",
|
||
display => $ENV{DISPLAY},
|
||
configfile => $tmpfile,
|
||
outdir => $ENV{OUTDIR},
|
||
testname => $ENV{TESTNAME},
|
||
valgrind => $ENV{VALGRIND},
|
||
strace => $ENV{STRACE},
|
||
xtrace => $ENV{XTRACE},
|
||
restart => $ENV{RESTART},
|
||
cv => $cv,
|
||
dont_create_temp_dir => $args{dont_create_temp_dir},
|
||
);
|
||
|
||
# force update of the cached socket path in lib/i3test
|
||
# as soon as i3 has started
|
||
$cv->cb(sub { get_socket_path(0) });
|
||
|
||
return $cv if $args{dont_block};
|
||
|
||
# blockingly wait until i3 is ready
|
||
$cv->recv;
|
||
|
||
return $i3_pid;
|
||
}
|
||
|
||
=head1 AUTHOR
|
||
|
||
Michael Stapelberg <michael@i3wm.org>
|
||
|
||
=cut
|
||
|
||
package i3test::X11;
|
||
use parent 'X11::XCB::Connection';
|
||
|
||
sub input_focus {
|
||
my $self = shift;
|
||
i3test::sync_with_i3();
|
||
|
||
return $self->SUPER::input_focus(@_);
|
||
}
|
||
|
||
1
|