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 => 29 ;
15 use Test::More tests => 24 ;
30 # test_null_events() ;
31 # test_plain_events () ;
32 # test_signal_events () ;
33 test_hard_timer_events () ;
34 test_soft_timer_events () ;
38 sub test_null_events {
40 local $SIG{__WARN__} = sub{} if
41 $Stem::Vars::Env{ 'event_loop' } eq 'event' ;
43 Stem::Event::start_loop() ;
45 ok( 1, 'null - event loop exit' ) ;
48 sub test_plain_events {
50 my $event = Stem::Event::Plain->new(
54 ok( ref $event, 'plain event created' ) ;
56 Stem::Event::start_loop() ;
58 ok( 1, 'plain - event loop exit' ) ;
61 # callback method for plain
67 ok( 1, 'plain event triggered' ) ;
70 sub test_signal_events {
73 if ( $^O =~ /win32/i ) {
75 skip( "signals not supported on windows", 3 ) ;
79 my $event = Stem::Event::Signal->new(
84 ok( ref $event, 'signal event created' ) ;
86 $self->{'sig_event'} = $event ;
92 Stem::Event::start_loop() ;
94 ok( 1, 'signal - event loop exit' ) ;
98 # callback method for signal
100 sub sig_int_handler {
104 ok( 1, 'signal event triggered' ) ;
106 $self->{'sig_event'}->cancel() ;
107 Stem::Event::stop_loop() ;
111 use constant INTERVAL => 4 ;
112 use constant SLEEP => 2 ;
113 use constant TIMER_CNT => 2 ;
115 # hard timeouts are timed from the beginning of the callback. so accumulated
116 # time in the callback doesn't affect the next callback.
118 sub test_hard_timer_events {
120 my $event = Stem::Event::Timer->new(
122 'method' => 'hard_timeout',
123 'interval' => INTERVAL,
124 'delay' => INTERVAL, # REMOVE - only for .10
129 ok( ref $event, 'hard timer event created' ) ;
130 print "$event\n" unless ref $event ;
132 $self->{'hard_timer_event'} = $event ;
133 $self->{'hard_timer_count'} = TIMER_CNT ;
134 $self->{'hard_timer_start_time'} = time ;
136 Stem::Event::start_loop() ;
138 ok( 1, 'hard timer - event loop exit' ) ;
145 ok( 1, 'hard timer event triggered' ) ;
147 if ( --$self->{'hard_timer_count'} > 0 ) {
150 my $delta = $time - $self->{'hard_timer_start_time'} ;
151 $self->{'hard_timer_start_time'} = $time ;
153 ok( $delta >= INTERVAL, 'hard delta' ) ;
155 hard_sleep( SLEEP ) ;
162 my $delta = $time - $self->{'hard_timer_start_time'} ;
164 #print "O $self->{'hard_timer_start_time'} T $time D $delta I ", INTERVAL, "\n" ;
166 ok( $delta >= INTERVAL, 'hard delta 2' ) ;
167 ok( $delta <= INTERVAL + SLEEP, 'hard delta sleep' ) ;
169 $self->{'hard_timer_event'}->cancel() ;
171 Stem::Event::stop_loop() ;
175 # Soft timeouts are timed from the end of the callback. so accumulated
176 # time in the callback delays the next callback.
178 sub test_soft_timer_events {
180 my $event = Stem::Event::Timer->new(
182 'method' => 'soft_timeout',
183 'interval' => INTERVAL,
184 'delay' => INTERVAL, # REMOVE - only for .10
188 ok( ref $event, 'soft timer event created' ) ;
189 # print "$event\n" unless ref $event ;
191 $self->{'soft_timer_event'} = $event ;
192 $self->{'soft_timer_count'} = TIMER_CNT ;
193 $self->{'soft_timer_start_time'} = time ;
195 #print "OTIME $self->{'soft_timer_start_time'}\n" ;
197 Stem::Event::start_loop() ;
199 ok( 1, 'soft timer - event loop exit' ) ;
206 ok( 1, 'soft timer event triggered' ) ;
208 if ( --$self->{'soft_timer_count'} > 0 ) {
211 my $delta = $time - $self->{'soft_timer_start_time'} ;
213 #print "T $time D $delta I ", INTERVAL, "\n" ;
215 ok( $delta >= INTERVAL, 'soft delta' ) ;
217 hard_sleep( SLEEP ) ;
219 #my $curr_time = time() ;
220 #print "DONE $curr_time\n" ;
226 my $delta = $time - $self->{'soft_timer_start_time'} ;
228 #print "TIME2 $time OTIME $self->{'soft_timer_start_time'} DEL $delta INTERVAL ", INTERVAL, "\n" ;
230 # ok( $delta >= INTERVAL, 'soft delta 2' ) ;
231 ok( $delta >= INTERVAL + SLEEP, 'soft delta 3' ) ;
233 $self->{'soft_timer_event'}->cancel() ;
235 Stem::Event::stop_loop() ;
240 Stem::Event::init_loop() ;
242 my $read_fh = gensym ;
243 my $write_fh = gensym ;
245 # get a pipe to read/write through.
248 socketpair( $read_fh, $write_fh, AF_UNIX, SOCK_STREAM, PF_UNSPEC ) ;
250 $self->{read_fh} = $read_fh ;
251 $self->{write_fh} = $write_fh ;
252 $self->{message} = 'Stem Read/Write Event' ;
254 # create the read and write events
256 my $read_event = Stem::Event::Read->new(
262 ok( ref $read_event, 'read event created' ) ;
263 $self->{'read_event'} = $read_event ;
265 my $write_event = Stem::Event::Write->new(
270 ok( ref $write_event, 'write event created' ) ;
271 $self->{'write_event'} = $write_event ;
273 Stem::Event::start_loop() ;
275 ok( 1, 'io - event loop exit' ) ;
282 ok( 1, 'read event timed out' ) ;
284 $self->{'write_event'}->start() ;
292 ok( 1, 'write event triggered' ) ;
294 syswrite( $self->{'write_fh'}, $self->{'message'} ) ;
296 $self->{'write_event'}->cancel() ;
303 ok(1, 'read event triggered' ) ;
307 my $bytes_read = sysread( $self->{'read_fh'}, $read_buf, 1000 ) ;
309 ok( $bytes_read, 'read byte count' ) ;
311 is( $read_buf, $self->{'message'}, 'read event compare' ) ;
313 $self->{'read_event'}->cancel() ;
315 Stem::Event::stop_loop() ;
318 # do a real hard sleep without alarm signal as that can screw up the tests
319 # sleep time is in (float) seconds
323 my( $sleep_time ) = @_ ;
325 #print "BEFORE TIME $sleep_time\n" ;
326 while( $sleep_time > 0 ) {
328 my $curr_time = time() ;
329 select( undef, undef, undef, $sleep_time ) ;
331 $sleep_time -= time() - $curr_time ;
333 #print "AFTER TIME $sleep_time\n" ;