1 #!/usr/local/bin/perl -w
4 $Stem::Vars::Env{ 'event_loop' } = shift ;
6 unless ( eval { require Time::HiRes } ) {
8 Time::HiRes->import( qw( time ) ) ;
14 use Test::More tests => 27 ;
30 test_plain_events () ;
31 test_signal_events () ;
32 test_hard_timer_events () ;
33 test_soft_timer_events () ;
37 sub test_null_events {
39 local $SIG{__WARN__} = sub{} if
40 $Stem::Vars::Env{ 'event_loop' } eq 'event' ;
42 Stem::Event::start_loop() ;
44 ok( 1, 'null - event loop exit' ) ;
47 sub test_plain_events {
49 my $event = Stem::Event::Plain->new(
53 ok( ref $event, 'plain - event created' ) ;
55 Stem::Event::start_loop() ;
57 ok( 1, 'plain - event loop exit' ) ;
60 # callback method for plain
66 <<<<<<< HEAD:t/event/event_test.pl
67 ok( 1, 'plain - event triggered' ) ;
69 ok( 1, 'plain event triggered' ) ;
70 Stem::Event::stop_loop() ;
71 >>>>>>> master:t/event/event_test.pl
74 sub test_signal_events {
77 if ( $^O =~ /win32/i ) {
79 skip( "signals not supported on windows", 3 ) ;
83 my $event2 = Stem::Event::Timer->new(
85 'method' => 'send_int_signal',
89 ok( ref $event2, 'signal delay timer created' ) ;
91 Stem::Event::start_loop() ;
93 ok( 1, 'signal - event loop exit' ) ;
99 my $event = Stem::Event::Signal->new(
104 ok( ref $event, 'signal - event created' ) ;
106 $self->{'sig_event'} = $event ;
114 # callback method for signal
116 sub sig_int_handler {
120 ok( 1, 'signal - event triggered' ) ;
122 $self->{'sig_event'}->cancel() ;
123 Stem::Event::stop_loop() ;
127 use constant INTERVAL => 4 ;
128 use constant SLEEP => 2 ;
129 use constant TIMER_CNT => 2 ;
131 # hard timeouts are timed from the beginning of the callback. so accumulated
132 # time in the callback doesn't affect the next callback.
134 sub test_hard_timer_events {
136 my $event = Stem::Event::Timer->new(
138 'method' => 'hard_timeout',
139 'interval' => INTERVAL,
140 'delay' => INTERVAL, # REMOVE - only for .10
145 ok( ref $event, 'hard timer - event created' ) ;
146 print "$event\n" unless ref $event ;
148 $self->{'hard_timer_event'} = $event ;
149 $self->{'hard_timer_count'} = TIMER_CNT ;
150 $self->{'hard_timer_start_time'} = time ;
152 Stem::Event::start_loop() ;
154 ok( 1, 'hard timer - event loop exit' ) ;
161 <<<<<<< HEAD:t/event/event_test.pl
162 ok( 1, 'hard timer - event triggered' ) ;
166 ok( 1, 'hard timer event triggered' ) ;
167 >>>>>>> master:t/event/event_test.pl
169 if ( --$self->{'hard_timer_count'} > 0 ) {
172 my $delta = $time - $self->{'hard_timer_start_time'} ;
173 $self->{'hard_timer_start_time'} = $time ;
175 ok( $delta >= INTERVAL, 'hard timer - delta' ) ;
177 hard_sleep( SLEEP ) ;
184 my $delta = $time - $self->{'hard_timer_start_time'} ;
186 #print "O $self->{'hard_timer_start_time'} T $time D $delta I ", INTERVAL, "\n" ;
188 ok( $delta >= INTERVAL, 'hard timer - delta 2' ) ;
189 ok( $delta <= INTERVAL + SLEEP, 'hard timer - delta sleep' ) ;
191 $self->{'hard_timer_event'}->cancel() ;
193 Stem::Event::stop_loop() ;
197 # Soft timeouts are timed from the end of the callback. so accumulated
198 # time in the callback delays the next callback.
200 sub test_soft_timer_events {
202 my $event = Stem::Event::Timer->new(
204 'method' => 'soft_timeout',
205 'interval' => INTERVAL,
206 'delay' => INTERVAL, # REMOVE - only for .10
210 ok( ref $event, 'soft timer - event created' ) ;
211 # print "$event\n" unless ref $event ;
213 $self->{'soft_timer_event'} = $event ;
214 $self->{'soft_timer_count'} = TIMER_CNT ;
215 $self->{'soft_timer_start_time'} = time ;
217 #print "OTIME $self->{'soft_timer_start_time'}\n" ;
219 Stem::Event::start_loop() ;
221 ok( 1, 'soft timer - event loop exit' ) ;
228 ok( 1, 'soft timer - event triggered' ) ;
230 if ( --$self->{'soft_timer_count'} > 0 ) {
233 my $delta = $time - $self->{'soft_timer_start_time'} ;
235 #print "T $time D $delta I ", INTERVAL, "\n" ;
237 ok( $delta >= INTERVAL, 'soft timer - delta' ) ;
239 hard_sleep( SLEEP ) ;
241 #my $curr_time = time() ;
242 #print "DONE $curr_time\n" ;
248 my $delta = $time - $self->{'soft_timer_start_time'} ;
250 #print "TIME2 $time OTIME $self->{'soft_timer_start_time'} DEL $delta INTERVAL ", INTERVAL, "\n" ;
252 # ok( $delta >= INTERVAL, 'soft timer - delta 2' ) ;
253 ok( $delta >= INTERVAL + SLEEP, 'soft timer - delta 3' ) ;
255 $self->{'soft_timer_event'}->cancel() ;
257 Stem::Event::stop_loop() ;
262 Stem::Event::init_loop() ;
264 my $read_fh = gensym ;
265 my $write_fh = gensym ;
267 # get a pipe to read/write through.
270 socketpair( $read_fh, $write_fh, AF_UNIX, SOCK_STREAM, PF_UNSPEC ) ;
272 $self->{read_fh} = $read_fh ;
273 $self->{write_fh} = $write_fh ;
274 $self->{message} = 'Stem Read/Write Event' ;
276 # create the read and write events
278 my $read_event = Stem::Event::Read->new(
284 ok( ref $read_event, 'read - event created' ) ;
285 $self->{'read_event'} = $read_event ;
287 my $write_event = Stem::Event::Write->new(
292 ok( ref $write_event, 'write - event created' ) ;
293 $self->{'write_event'} = $write_event ;
295 Stem::Event::start_loop() ;
297 ok( 1, 'io event - loop exit' ) ;
304 ok( 1, 'read - event timed out' ) ;
306 $self->{'write_event'}->start() ;
314 ok( 1, 'write - event triggered' ) ;
316 syswrite( $self->{'write_fh'}, $self->{'message'} ) ;
318 $self->{'write_event'}->cancel() ;
325 ok(1, 'read - event triggered' ) ;
329 my $bytes_read = sysread( $self->{'read_fh'}, $read_buf, 1000 ) ;
331 ok( $bytes_read, 'read - byte count' ) ;
333 is( $read_buf, $self->{'message'}, 'read event compare' ) ;
335 $self->{'read_event'}->cancel() ;
337 Stem::Event::stop_loop() ;
340 # do a real hard sleep without alarm signal as that can screw up the tests
341 # sleep time is in (float) seconds
345 my( $sleep_time ) = @_ ;
347 #print "BEFORE TIME $sleep_time\n" ;
348 while( $sleep_time > 0 ) {
350 my $curr_time = time() ;
351 select( undef, undef, undef, $sleep_time ) ;
353 $sleep_time -= time() - $curr_time ;
355 #print "AFTER TIME $sleep_time\n" ;