my $numtests = scalar @testfiles;
+# When the user specifies displays, we don’t run multi-monitor tests at all
+# (because we don’t know which displaynumber is the X-Server with multiple
+# monitors).
+my $multidpy = undef;
+
# No displays specified, let’s start some Xdummy instances.
-@displays = start_xdummy($parallel, $numtests) if @displays == 0;
+if (@displays == 0) {
+ my $dpyref;
+ ($dpyref, $multidpy) = start_xdummy($parallel, $numtests);
+ @displays = @$dpyref;
+}
# 1: create an output directory for this test-run
my $outdir = "testsuite-";
# 2: keep the connection open so that i3 is not the only client. this prevents
# the X server from exiting (Xdummy will restart it, but not quick enough
# sometimes)
-my @worker;
+my @single_worker;
for my $display (@displays) {
my $screen;
my $x = X11::XCB::Connection->new(display => $display);
die "Could not connect to display $display\n";
} else {
# start a TestWorker for each display
- push @worker, worker($display, $x, $outdir);
+ push @single_worker, worker($display, $x, $outdir);
+ }
+}
+
+my @multi_worker;
+if (defined($multidpy)) {
+ my $x = X11::XCB::Connection->new(display => $multidpy);
+ if ($x->has_error) {
+ die "Could not connect to multi-monitor display $multidpy\n";
+ } else {
+ push @multi_worker, worker($multidpy, $x, $outdir);
}
}
my $num = @testfiles;
my $harness = TAP::Harness->new({ });
+my @single_monitor_tests = grep { m,^t/([0-9]+)-, && $1 < 500 } @testfiles;
+my @multi_monitor_tests = grep { m,^t/([0-9]+)-, && $1 >= 500 } @testfiles;
+
my $aggregator = TAP::Parser::Aggregator->new();
$aggregator->start();
-status_init(displays => \@displays, tests => $num);
+status_init(displays => [ @displays, $multidpy ], tests => $num);
-my $cv = AE::cv;
+my $single_cv = AE::cv;
+my $multi_cv = AE::cv;
# We start tests concurrently: For each display, one test gets started. Every
# test starts another test after completing.
-for (@worker) { $cv->begin; take_job($_) }
+for (@single_worker) {
+ $single_cv->begin;
+ take_job($_, $single_cv, \@single_monitor_tests);
+}
+for (@multi_worker) {
+ $multi_cv->begin;
+ take_job($_, $multi_cv, \@multi_monitor_tests);
+}
-$cv->recv;
+$single_cv->recv;
+$multi_cv->recv;
$aggregator->stop();
# triggered to finish testing.
#
sub take_job {
- my ($worker) = @_;
+ my ($worker, $cv, $tests) = @_;
- my $test = shift @testfiles
+ my $test = shift @$tests
or return $cv->end;
my $display = $worker->{display};
push @done, [ $test, $output ];
undef $w;
- take_job($worker);
+ take_job($worker, $cv, $tests);
}
);
}
our @EXPORT = qw(start_xdummy);
+my $x_socketpath = '/tmp/.X11-unix/X';
+
# reads in a whole file
sub slurp {
open(my $fh, '<', shift) or return '';
<$fh>;
}
+# forks an Xdummy or Xdmx process
+sub fork_xserver {
+ my $displaynum = shift;
+ my $pid = fork();
+ die "Could not fork: $!" unless defined($pid);
+ if ($pid == 0) {
+ # Child, close stdout/stderr, then start Xdummy.
+ close STDOUT;
+ close STDERR;
+
+ exec @_;
+ exit 1;
+ }
+ push(@complete_run::CLEANUP, sub {
+ kill(15, $pid);
+ # Unlink the X11 socket, Xdmx seems to leave it there.
+ unlink($x_socketpath . $displaynum);
+ });
+
+ return $x_socketpath . $displaynum;
+}
+
+# Blocks until the socket paths specified in the given array reference actually
+# exist.
+sub wait_for_x {
+ my ($sockets_waiting) = @_;
+
+ # Wait until Xdmx actually runs. Pretty ugly solution, but as long as we
+ # can’t socket-activate X11…
+ while (1) {
+ @$sockets_waiting = grep { ! -S $_ } @$sockets_waiting;
+ last unless @$sockets_waiting;
+ sleep 0.1;
+ }
+}
+
=head2 start_xdummy($parallel)
Starts C<$parallel> (or number of cores * 2 if undef) Xdummy processes (see
=cut
-my $x_socketpath = '/tmp/.X11-unix/X';
-
sub start_xdummy {
my ($parallel, $numtests) = @_;
# If /proc/cpuinfo does not exist, we fall back to 2 cores.
$num_cores ||= 2;
- $parallel ||= $num_cores * 2;
+ # If unset, we use num_cores * 2, plus two extra xdummys to combine to a
+ # multi-monitor setup using Xdmx.
+ $parallel ||= ($num_cores * 2) + 2;
# If we are running a small number of tests, don’t over-parallelize.
$parallel = $numtests if $numtests < $parallel;
+ # Ensure we have at least 1 X-Server plus two X-Servers for multi-monitor
+ # tests.
+ $parallel = 3 if $parallel < 3;
+
# First get the last used display number, then increment it by one.
# Effectively falls back to 1 if no X server is running.
my ($displaynum) = map { /(\d+)$/ } reverse sort glob($x_socketpath . '*');
say "Starting $parallel Xdummy instances, starting at :$displaynum...";
my @sockets_waiting;
- for my $idx (0 .. ($parallel-1)) {
- my $pid = fork();
- die "Could not fork: $!" unless defined($pid);
- if ($pid == 0) {
- # Child, close stdout/stderr, then start Xdummy.
- close STDOUT;
- close STDERR;
- # make sure this display isn’t in use yet
- $displaynum++ while -e ($x_socketpath . $displaynum);
-
- # We use -config /dev/null to prevent Xdummy from using the system
- # Xorg configuration. The tests should be independant from the
- # actual system X configuration.
- exec './Xdummy', ":$displaynum", '-config', '/dev/null';
- exit 1;
- }
- push(@complete_run::CLEANUP, sub { kill(15, $pid) });
+ for (1 .. $parallel) {
+ # We use -config /dev/null to prevent Xdummy from using the system
+ # Xorg configuration. The tests should be independant from the
+ # actual system X configuration.
+ my $socket = fork_xserver($displaynum, './Xdummy', ":$displaynum",
+ '-config', '/dev/null');
push(@displays, ":$displaynum");
- push(@sockets_waiting, $x_socketpath . $displaynum);
+ push(@sockets_waiting, $socket);
$displaynum++;
}
- # Wait until the X11 sockets actually appear. Pretty ugly solution, but as
- # long as we can’t socket-activate X11…
- while (1) {
- @sockets_waiting = grep { ! -S $_ } @sockets_waiting;
- last unless @sockets_waiting;
- sleep 0.1;
- }
+ wait_for_x(\@sockets_waiting);
+
+ # Now combine the last two displays to a multi-monitor display using Xdmx
+ my $first = pop @displays;
+ my $second = pop @displays;
+
+ # make sure this display isn’t in use yet
+ $displaynum++ while -e ($x_socketpath . $displaynum);
+ say 'starting xdmx on display :' . $displaynum;
+
+ my $multidpy = ":$displaynum";
+ my $socket = fork_xserver($displaynum, 'Xdmx', '+xinerama', '-xinput',
+ 'local', '-display', $first, '-display', $second, '-ac', $multidpy);
+ wait_for_x([ $socket ]);
- return @displays;
+ return \@displays, $multidpy;
}
1
projects / i3 / i3 / commitdiff