X11-Xlib

 view release on metacpan or  search on metacpan

t/20-xevent.t  view on Meta::CPAN

#!/usr/bin/env perl
use strict;
use warnings;
use Test::More tests => 4;

use_ok('X11::Xlib::XEvent') or die;
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

subtest blank_event => sub {
    # Create a new XEvent (defaults to XErrorEvent)
    my $blank_event= new_ok( 'X11::Xlib::XEvent', [], 'blank event' );
    ok( defined $blank_event->buffer, 'buffer is defined' );
    ok( length($blank_event->buffer) > 0, 'and has non-zero length' );
    is( $blank_event->type,    0,     'type=0' );
    is( $blank_event->display, undef, 'display=undef' );
    is( $blank_event->serial,  0,     'serial=0' );
    like( $blank_event->summarize, qr/XEvent/ );

t/21-xvisualinfo.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More tests => 11;
use Scalar::Util 'weaken';

use_ok('X11::Xlib::XVisualInfo') or die;
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

# Create a new XEvent
my $struct= new_ok( 'X11::Xlib::XVisualInfo', [], 'blank' );
ok( defined $struct->buffer, 'buffer is defined' );
ok( length($struct->buffer) > 0, 'and has non-zero length' );

my $struct2= bless \("x"x X11::Xlib::XVisualInfo->_sizeof), 'X11::Xlib::XVisualInfo';

$struct->red_mask(0xFF0000);
$struct->blue_mask(0x0000FF);

t/22-xrectangle.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More tests => 10;

use_ok('X11::Xlib::XRectangle') or die;
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

# Create a new XEvent
my $struct= new_ok( 'X11::Xlib::XRectangle', [], 'blank' );
ok( defined $struct->buffer, 'buffer is defined' );
ok( length($struct->buffer) > 0, 'and has non-zero length' );

my $struct2= bless \("x"x X11::Xlib::XVisualInfo->_sizeof), 'X11::Xlib::XRectangle';

$struct->x(-2);
$struct->y(55);

t/30-connection.t  view on Meta::CPAN

use strict;
use warnings;
use Scalar::Util 'isweak';
use IO::Handle;
use Test::More;

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 17;

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

use_ok('X11::Xlib') or BAIL_OUT;

my $conn= X11::Xlib::XOpenDisplay();
isa_ok( $conn, 'X11::Xlib', 'new connection' );
note 'connected to '.X11::Xlib::XDisplayName();

my $pointer1= $conn->_pointer_value;
ok( defined $pointer1,     'pointer defined' );
is( ref $pointer1, '',     'is a plain scalar' );

t/31-xlib-fatal.t  view on Meta::CPAN

use strict;
use warnings;
use Scalar::Util 'isweak';
use IO::Handle;
use Test::More;

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 20;

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

use X11::Xlib qw( XOpenDisplay ConnectionNumber );

my $conn;
is( err{ $conn= XOpenDisplay(); }, '', 'connected' );
isa_ok( $conn, 'X11::Xlib', 'display connection' );

my $conn2= XOpenDisplay();
my $conn3= XOpenDisplay();

t/32-xlib-nonfatal.t  view on Meta::CPAN

use IO::Handle;
use Test::More;

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 12;

use X11::Xlib qw( XOpenDisplay ConnectionNumber RootWindow );

my $conn;
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $conn->XSync(); $ret= $@; } $ret }
is( err{ $conn= XOpenDisplay(); }, '', 'connected' );
isa_ok( $conn, 'X11::Xlib', 'display connection' );
my $root= RootWindow($conn);

my $conn2= XOpenDisplay();
is( scalar X11::Xlib->_all_connections, 2, 'two registered connections' );

ok( !$X11::Xlib::_error_nonfatal_installed,    'handler not installed' );

X11::Xlib->on_error(sub {

t/33-atom.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib qw( KeyPress );
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );
$dpy->on_error(sub { my ($dpy, $err)= @_; note $err->summarize; }); # ignore non-fatal errors

ok( (my $a_utf8= $dpy->XInternAtom('UTF8_STRING', 0) ), 'get atom UTF8_STRING' );
is( $dpy->XGetAtomName($a_utf8), 'UTF8_STRING', 'get name UTF8_STRING' );
ok( !$dpy->XInternAtom("SomeTokenThatProbablyDoesn'tExist", 1), 'nonexistent name returns false' );

t/35-event-queue.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib qw( KeyPress );
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 9;

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );

# This test does a lot of blocking things, so set up an alarm to use as a watchdog
$SIG{ALRM}= sub { fail("Timeout"); exit; };
alarm 5;

t/36-input.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib ':all';
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 2;

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );

subtest XQueryPointer => sub {
    my @ret= XQueryPointer($dpy, RootWindow($dpy));
    is( scalar @ret, 7, 'Return as list' );

t/37-input-kb.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib ':all';
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 8;

my $TEST_DESTRUCTIVE= !!$ENV{TEST_DESTRUCTIVE};
sub skip_destructive($) {
    skip "TEST_DESTRUCTIVE is false; skipping destrutive tests", shift
        unless $TEST_DESTRUCTIVE;
}

t/40-screen-attrs.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib ':fn_screen';
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 10;

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );

ok( ScreenCount($dpy)     > 0, 'screen count' );
ok( RootWindow($dpy)      > 0, 'root window'  );
ok( DefaultColormap($dpy) > 0, 'default colormap' );

t/42-window.t  view on Meta::CPAN

use strict;
use warnings;
use Test::More;
use X11::Xlib qw( :fn_win :const_win :const_winattr :const_sizehint :const_event_mask RootWindow XSync None Success );

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; XSync($dpy); $ret= $@; } $ret }

my @args= ($dpy, RootWindow($dpy), 0, 0, 50, 50, 0,
    $dpy->DefaultDepth, InputOutput, $dpy->DefaultVisual,
    0, {});
my $win_id;
is( err{ $win_id= XCreateWindow(@args) }, '', 'CreateWindow' )
    or diag explain \@args;
ok( $win_id > 0, 'got window id' );

my ($netwmname, $type_utf8, $wm_proto, $wm_dest_win)

t/43-pixmap.t  view on Meta::CPAN

#!/usr/bin/env perl

use strict;
use warnings;
use Test::More;
use X11::Xlib qw( :all );
sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $ret= $@; } $ret }

plan skip_all => "No X11 Server available"
    unless $ENV{DISPLAY};
plan tests => 7;

my $dpy= new_ok( 'X11::Xlib', [], 'connect to X11' );

my $s= $dpy->screen;
ok( (my $pmap= $dpy->new_pixmap($s->root_window, 128, 128, $s->visual_info->depth)), 'XCreatePixmap' );
is( $pmap->width, 128, 'width' );

t/70-xcomposite.t  view on Meta::CPAN

    unless X11::Xlib->can('XCompositeVersion');

my $x= try { X11::SandboxServer->new(title => $FindBin::Script) };
plan skip_all => 'Need Xephyr to run Xcomposite tests'
    unless defined $x;

my $display= $x->client;
plan skip_all => 'Xcomposite not supported by server'
    unless $display->XCompositeQueryVersion;

sub err(&) { my $code= shift; my $ret; { local $@= ''; eval { $code->() }; $display->flush_sync; $ret= $@; } $ret }

my ($root, $overlay, $region);
note "local Xc ver = ".X11::Xlib::XCompositeVersion()." server Xc ver = ".join('.', $display->XCompositeQueryVersion);
is( err{ $root= $display->root_window }, '', 'get root window' );
note "root = $root";
is( err{ $display->XCompositeRedirectSubwindows($root, CompositeRedirectAutomatic) }, '', 'XCompositeRedirectSubwindows' );
is( err{ $display->XSelectInput($root, SubstructureNotifyMask) }, '', 'XSelectInput' );
is( err{ $overlay= $display->XCompositeGetOverlayWindow($root) }, '', 'XCompositeGetOverlayWindow' );
note "overlay = $overlay";