TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.start should start time running
ok 6 should be equal
ok 7 should be equal
ok 8 should be equal
ok 9 should be equal
# when time is running and tick takes longer than maxTimestep, time should stop running
!!!Spiral Of Death!!!
ok 10 should be equal
ok 11 should be equal
ok 12 should be equal
# time.stop should be a function
ok 13 should be equal
# time should emit a stop event when stop is called
ok 14 stop fired
# time.stop should stop time running
ok 15 should be equal
ok 16 should be equal
ok 17 should be equal
# calling time.stop when time is stopped should not start time
ok 18 should be equal
ok 19 should be equal
ok 20 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 21 fire fixedupdate
ok 22 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 23 fire fixedupdate
# time should fire multiple fixedupdate event with deltaTime === fixedTimestep when tick takes multiple fixedTimestep
ok 24 fire fixedupdate
ok 25 should be equal
ok 26 fire fixedupdate
ok 27 should be equal
ok 28 fire fixedupdate
ok 29 should be equal
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 30 fire fixedupdate
ok 31 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 32 fire update
ok 33 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes multiple renderTimestep
ok 34 fire update
ok 35 should be equal
# time should fire single update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 36 fire update
ok 37 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 38 fire update
# time should fire update event after fixedupdate event
ok 39 should be equal
ok 40 should be equal
# time should fire render event after update event
ok 41 should be equal
ok 42 should be equal
1..42
# tests 42
# pass 42
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time.tick should be a function
ok 2 should be equal
# time.tick(x) should emit the correct events in the correct order
ok 3 should be equivalent
# time.start should be a function
ok 4 should be equal
# time should emit a start event when start is called
ok 5 start fired
# time.stop should be a function
ok 6 should be equal
# calling time.stop when time is stopped should not start time
ok 7 update event not fired
# time should emit a stop event when stop is called
ok 8 stop fired
# time should fire fixedupdate event with deltaTime === fixedTimestep, when tick takes fixedTimestep
ok 9 fire fixedupdate
ok 10 should be equal
# time should not fire fixedupdate event when tick takes less than fixedTimestep
ok 11 fire fixedupdate
# time should fire fixedupdate event with deltaTime === fixedTimestep when tick takes more than fixedTimestep
ok 12 fire fixedupdate
ok 13 should be equal
# time should fire update with deltaTime === time since last update when tick takes renderTimestep
ok 14 fire update
ok 15 should be equal
# time should fire update event with deltaTime === frameTime when tick takes longer than renderTimestep
ok 16 fire update
ok 17 should be equal
# time should not fire update event when tick takes shorter than renderTimestep
ok 18 fire update
# time should fire update event after fixedupdate event
ok 19 should be equal
ok 20 should be equal
# time should fire render event after update event
ok 21 should be equal
ok 22 should be equal
1..22
# tests 22
# pass 22
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
ok 4 (unnamed assert)
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 5 fire fixedupdate
ok 6 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 7 fire update
ok 8 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 9 fire update
ok 10 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
ok 11 (unnamed assert)
# time should fire update event after fixedupdate event
ok 12 should be equal
ok 13 should be equal
# time should fire render event after update event
ok 14 should be equal
ok 15 should be equal
1..15
# tests 15
# pass 15
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok
TAP version 13
# Time
ok 1 class should exist
# time should fire fixedupdate event with deltaTime === fixedTimestep, when frame takes fixedTimestep
ok 2 fire fixedupdate
ok 3 should be equal
# time should not fire fixedupdate event when frame takes less than fixedTimestep
# time should fire fixedupdate event with deltaTime === fixedTimestep when frame takes more than fixedTimestep
ok 4 fire fixedupdate
ok 5 should be equal
# time should fire update with deltaTime === time since last update when frame takes renderTimestep
ok 6 fire update
ok 7 should be equal
# time should fire update event with deltaTime === frameTime when frame takes longer than renderTimestep
ok 8 fire update
ok 9 should be equal
# time should not fire update event when frame takes shorter than renderTimestep
# time should fire update event after fixedupdate event
ok 10 should be equal
ok 11 should be equal
# time should fire render event after update event
ok 12 should be equal
ok 13 should be equal
1..13
# tests 13
# pass 13
# ok