310 lines
10 KiB
Python
310 lines
10 KiB
Python
#################################### IMPORTS ###################################
|
|
import os
|
|
|
|
if __name__ == '__main__':
|
|
import sys
|
|
pkg_dir = os.path.split(os.path.abspath(__file__))[0]
|
|
parent_dir, pkg_name = os.path.split(pkg_dir)
|
|
is_pygame_pkg = (pkg_name == 'tests' and
|
|
os.path.split(parent_dir)[1] == 'pygame')
|
|
if not is_pygame_pkg:
|
|
sys.path.insert(0, parent_dir)
|
|
else:
|
|
is_pygame_pkg = __name__.startswith('pygame.tests.')
|
|
|
|
import unittest
|
|
import pygame
|
|
from pygame.compat import as_unicode
|
|
|
|
################################################################################
|
|
|
|
class EventTypeTest(unittest.TestCase):
|
|
def test_Event(self):
|
|
# __doc__ (as of 2008-08-02) for pygame.event.Event:
|
|
|
|
# pygame.event.Event(type, dict): return Event
|
|
# pygame.event.Event(type, **attributes): return Event
|
|
# create a new event object
|
|
#
|
|
# Creates a new event with the given type. The event is created with
|
|
# the given attributes and values. The attributes can come from a
|
|
# dictionary argument, or as string keys from a dictionary.
|
|
#
|
|
# The given attributes will be readonly attributes on the new event
|
|
# object itself. These are the only attributes on the Event object,
|
|
# there are no methods attached to Event objects.
|
|
|
|
e = pygame.event.Event(pygame.USEREVENT, some_attr=1, other_attr='1')
|
|
|
|
self.assertEquals(e.some_attr, 1)
|
|
self.assertEquals(e.other_attr, "1")
|
|
|
|
# Event now uses tp_dictoffset and tp_members: request 62
|
|
# on Motherhamster Bugzilla.
|
|
self.assertEquals(e.type, pygame.USEREVENT)
|
|
self.assert_(e.dict is e.__dict__)
|
|
e.some_attr = 12
|
|
self.assertEquals(e.some_attr, 12)
|
|
e.new_attr = 15
|
|
self.assertEquals(e.new_attr, 15)
|
|
|
|
# For Python 2.x a TypeError is raised for a readonly member;
|
|
# for Python 3.x it is an AttributeError.
|
|
self.assertRaises((TypeError, AttributeError), setattr, e, 'type', 0)
|
|
self.assertRaises((TypeError, AttributeError), setattr, e, 'dict', None)
|
|
|
|
# Ensure attributes are visible to dir(), part of the original
|
|
# posted request.
|
|
d = dir(e)
|
|
self.assert_('type' in d)
|
|
self.assert_('dict' in d)
|
|
self.assert_('__dict__' in d)
|
|
self.assert_('some_attr' in d)
|
|
self.assert_('other_attr' in d)
|
|
self.assert_('new_attr' in d)
|
|
|
|
def test_as_str(self):
|
|
# Bug reported on Pygame mailing list July 24, 2011:
|
|
# For Python 3.x str(event) to raises an UnicodeEncodeError when
|
|
# an event attribute is a string with a non-ascii character.
|
|
try:
|
|
str(pygame.event.Event(1, a=as_unicode(r"\xed")))
|
|
except UnicodeEncodeError:
|
|
self.fail("Event object raised exception for non-ascii character")
|
|
# Passed.
|
|
|
|
|
|
race_condition_notification = """
|
|
This test is dependent on timing. The event queue is cleared in preparation for
|
|
tests. There is a small window where outside events from the OS may have effected
|
|
results. Try running the test again.
|
|
"""
|
|
|
|
class EventModuleTest(unittest.TestCase):
|
|
def setUp(self):
|
|
# flush events
|
|
pygame.display.init()
|
|
pygame.event.clear()
|
|
self.assert_(not pygame.event.get())
|
|
|
|
def tearDown(self):
|
|
pygame.display.quit()
|
|
|
|
def test_event_attribute(self):
|
|
e1 = pygame.event.Event(pygame.USEREVENT, attr1='attr1')
|
|
self.assertEqual(e1.attr1, 'attr1')
|
|
|
|
def test_set_blocked(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.set_blocked:
|
|
|
|
# pygame.event.set_blocked(type): return None
|
|
# pygame.event.set_blocked(typelist): return None
|
|
# pygame.event.set_blocked(None): return None
|
|
# control which events are allowed on the queue
|
|
|
|
pygame.event.set_blocked(2)
|
|
|
|
self.assert_(pygame.event.get_blocked(2))
|
|
|
|
pygame.event.post(pygame.event.Event(2))
|
|
|
|
events = pygame.event.get()
|
|
should_be_blocked = [e for e in events if e.type == 2]
|
|
|
|
self.assertEquals(should_be_blocked, [])
|
|
|
|
def test_post__and_poll(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.post:
|
|
|
|
# pygame.event.post(Event): return None
|
|
# place a new event on the queue
|
|
|
|
e1 = pygame.event.Event(pygame.USEREVENT, attr1='attr1')
|
|
|
|
pygame.event.post(e1)
|
|
|
|
posted_event = pygame.event.poll()
|
|
self.assertEquals (
|
|
e1.attr1, posted_event.attr1, race_condition_notification
|
|
)
|
|
|
|
# fuzzing event types
|
|
for i in range(1, 11):
|
|
pygame.event.post(pygame.event.Event(i))
|
|
self.assertEquals (
|
|
pygame.event.poll().type, i, race_condition_notification
|
|
)
|
|
def test_post_large_user_event(self):
|
|
pygame.event.post(pygame.event.Event(pygame.USEREVENT, {'a': "a" * 1024}))
|
|
|
|
e = pygame.event.poll()
|
|
self.assertEquals(e.type, pygame.USEREVENT)
|
|
self.assertEquals(e.a, "a" * 1024)
|
|
|
|
|
|
|
|
def test_get(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.get:
|
|
|
|
# pygame.event.get(): return Eventlist
|
|
# pygame.event.get(type): return Eventlist
|
|
# pygame.event.get(typelist): return Eventlist
|
|
# get events from the queue
|
|
|
|
# Put 10 events on the queue
|
|
for _ in range(1, 11):
|
|
pygame.event.post(pygame.event.Event(pygame.USEREVENT))
|
|
|
|
self.assert_ ( len(pygame.event.get()) >= 10 )
|
|
|
|
def test_clear(self):
|
|
|
|
# __doc__ (as of 2008-06-25) for pygame.event.clear:
|
|
|
|
# pygame.event.clear(): return None
|
|
# pygame.event.clear(type): return None
|
|
# pygame.event.clear(typelist): return None
|
|
# remove all events from the queue
|
|
|
|
for _ in range(1, 11):
|
|
pygame.event.post(pygame.event.Event(_))
|
|
|
|
self.assert_(pygame.event.poll()) # there are some events on queue
|
|
|
|
pygame.event.clear()
|
|
|
|
self.assert_(not pygame.event.poll(), race_condition_notification)
|
|
|
|
def test_event_name(self):
|
|
|
|
# __doc__ (as of 2008-06-25) for pygame.event.event_name:
|
|
|
|
# pygame.event.event_name(type): return string
|
|
# get the string name from and event id
|
|
|
|
self.assertEquals(pygame.event.event_name(2), "KeyDown")
|
|
self.assertEquals(pygame.event.event_name(24), "UserEvent")
|
|
|
|
def test_wait(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.wait:
|
|
|
|
# pygame.event.wait(): return Event
|
|
# wait for a single event from the queue
|
|
|
|
pygame.event.post ( pygame.event.Event(2) )
|
|
self.assert_(pygame.event.wait())
|
|
|
|
def test_peek(self):
|
|
|
|
# __doc__ (as of 2008-06-25) for pygame.event.peek:
|
|
|
|
# pygame.event.peek(type): return bool
|
|
# pygame.event.peek(typelist): return bool
|
|
# test if event types are waiting on the queue
|
|
|
|
event_types = [2, 3, 4]
|
|
|
|
for event_type in event_types:
|
|
pygame.event.post (
|
|
pygame.event.Event(event_type)
|
|
)
|
|
self.assert_(pygame.event.peek(event_type))
|
|
|
|
self.assert_(pygame.event.peek(event_types))
|
|
|
|
def test_set_allowed(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.set_allowed:
|
|
|
|
# pygame.event.set_allowed(type): return None
|
|
# pygame.event.set_allowed(typelist): return None
|
|
# pygame.event.set_allowed(None): return None
|
|
# control which events are allowed on the queue
|
|
|
|
pygame.event.set_blocked(2)
|
|
self.assert_(pygame.event.get_blocked(2))
|
|
pygame.event.set_allowed(2)
|
|
self.assert_(not pygame.event.get_blocked(2))
|
|
|
|
def test_pump(self):
|
|
# __doc__ (as of 2008-06-25) for pygame.event.pump:
|
|
|
|
# pygame.event.pump(): return None
|
|
# internally process pygame event handlers
|
|
|
|
# see it doesn't cause an error
|
|
pygame.event.pump()
|
|
|
|
def test_set_grab__and_get_symmetric(self):
|
|
|
|
# __doc__ (as of 2008-06-25) for pygame.event.set_grab:
|
|
|
|
# pygame.event.set_grab(bool): return None
|
|
# control the sharing of input devices with other applications
|
|
|
|
# If we don't have a real display, don't do the test.
|
|
if os.environ.get('SDL_VIDEODRIVER') == 'dummy':
|
|
return
|
|
|
|
pygame.event.set_grab(True)
|
|
self.assert_(pygame.event.get_grab())
|
|
pygame.event.set_grab(False)
|
|
self.assert_(not pygame.event.get_grab())
|
|
|
|
def test_event_equality(self):
|
|
a = pygame.event.Event(1, a=1)
|
|
b = pygame.event.Event(1, a=1)
|
|
c = pygame.event.Event(2, a=1)
|
|
d = pygame.event.Event(1, a=2)
|
|
|
|
self.failUnless(a == a)
|
|
self.failIf(a != a)
|
|
self.failUnless(a == b)
|
|
self.failIf(a != b)
|
|
self.failUnless(a != c)
|
|
self.failIf(a == c)
|
|
self.failUnless(a != d)
|
|
self.failIf(a == d)
|
|
|
|
def todo_test_get_blocked(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.event.get_blocked:
|
|
|
|
# pygame.event.get_blocked(type): return bool
|
|
# test if a type of event is blocked from the queue
|
|
#
|
|
# Returns true if the given event type is blocked from the queue.
|
|
|
|
self.fail()
|
|
|
|
def todo_test_get_grab(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.event.get_grab:
|
|
|
|
# pygame.event.get_grab(): return bool
|
|
# test if the program is sharing input devices
|
|
#
|
|
# Returns true when the input events are grabbed for this application.
|
|
# Use pygame.event.set_grab() to control this state.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
def todo_test_poll(self):
|
|
|
|
# __doc__ (as of 2008-08-02) for pygame.event.poll:
|
|
|
|
# pygame.event.poll(): return Event
|
|
# get a single event from the queue
|
|
#
|
|
# Returns a single event from the queue. If the event queue is empty
|
|
# an event of type pygame.NOEVENT will be returned immediately. The
|
|
# returned event is removed from the queue.
|
|
#
|
|
|
|
self.fail()
|
|
|
|
################################################################################
|
|
|
|
if __name__ == '__main__':
|
|
unittest.main()
|