def test_keypresses(self):
if not self.is_interactive:
py.test.skip("interactive test only")
RSDL.EnableUNICODE(1)
print
print "Keys pressed in the Pygame window should be printed below."
print " Use Escape to quit."
event = lltype.malloc(RSDL.Event, flavor='raw')
try:
while True:
ok = RSDL.WaitEvent(event)
assert rffi.cast(lltype.Signed, ok) == 1
c_type = rffi.getintfield(event, 'c_type')
if c_type == RSDL.KEYDOWN:
p = rffi.cast(RSDL.KeyboardEventPtr, event)
if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE:
print 'Escape key'
break
char = rffi.getintfield(p.c_keysym, 'c_unicode')
if char != 0:
print 'Key:', unichr(char).encode('utf-8')
else:
print 'Some special key'
else:
print '(event of type %d)' % c_type
finally:
lltype.free(event, flavor='raw')
def test_poll(self):
if not self.is_interactive:
py.test.skip("interactive test only")
import time, sys
RSDL.EnableUNICODE(1)
print
print "Keys pressed in the Pygame window give a dot."
print " Wait 3 seconds to quit."
timeout = time.time() + 3
event = lltype.malloc(RSDL.Event, flavor='raw')
try:
while True:
# busy polling
ok = RSDL.PollEvent(event)
ok = rffi.cast(lltype.Signed, ok)
assert ok >= 0
if ok > 0:
c_type = rffi.getintfield(event, 'c_type')
if c_type == RSDL.KEYDOWN:
sys.stderr.write('.')
p = rffi.cast(RSDL.KeyboardEventPtr, event)
if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE:
print 'Escape key'
break
timeout = time.time() + 3
else:
if time.time() > timeout:
break
time.sleep(0.05)
finally:
lltype.free(event, flavor='raw')
def test_image_pixels():
for filename in ["demo.jpg", "demo.png"]:
image = RIMG.Load(os.path.join(autopath.this_dir, filename))
assert image
assert rffi.getintfield(image.c_format, 'c_BytesPerPixel') in (3, 4)
RSDL.LockSurface(image)
result = {}
try:
rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw')
try:
for y in range(23):
for x in range(y % 13, 17, 13):
color = RSDL_helper.get_pixel(image, x, y)
RSDL.GetRGB(color, image.c_format, rffi.ptradd(rgb, 0),
rffi.ptradd(rgb, 1), rffi.ptradd(rgb, 2))
r = rffi.cast(lltype.Signed, rgb[0])
g = rffi.cast(lltype.Signed, rgb[1])
b = rffi.cast(lltype.Signed, rgb[2])
result[x, y] = r, g, b
finally:
lltype.free(rgb, flavor='raw')
finally:
RSDL.UnlockSurface(image)
RSDL.FreeSurface(image)
for x, y in result:
f = (x * 17 + y * 23) / float(17 * 17 + 23 * 23)
expected_r = int(255.0 * (1.0 - f))
expected_g = 0
expected_b = int(255.0 * f)
r, g, b = result[x, y]
assert abs(r - expected_r) < 10
assert abs(g - expected_g) < 10
assert abs(b - expected_b) < 10
def setup_method(self, meth):
if not conftest.option.view:
py.test.skip("'--view' not specified, "
"skipping tests that open a window")
assert RSDL.Init(RSDL.INIT_VIDEO) >= 0
self.screen = RSDL.SetVideoMode(640, 480, 32, 0)
assert self.screen
self.is_interactive = sys.stdout.isatty()
def test_fillrect_full(self):
fmt = self.screen.c_format
for colorname, r, g, b in [('dark red', 128, 0, 0),
('yellow', 255, 255, 0),
('blue', 0, 0, 255)]:
color = RSDL.MapRGB(fmt, r, g, b)
RSDL.FillRect(self.screen, lltype.nullptr(RSDL.Rect), color)
RSDL.Flip(self.screen)
self.check("Screen filled with %s" % colorname)
def test_surface_basic():
assert RSDL.Init(RSDL.INIT_VIDEO) >= 0
surface = RSDL.CreateRGBSurface(0, 150, 50, 32, r_uint(0x000000FF),
r_uint(0x0000FF00), r_uint(0x00FF0000),
r_uint(0xFF000000))
assert surface
assert rffi.getintfield(surface, 'c_w') == 150
assert rffi.getintfield(surface, 'c_h') == 50
RSDL.FreeSurface(surface)
RSDL.Quit()
def test_blit_rect(self):
surface = RSDL.CreateRGBSurface(0, 150, 50, 32,
r_uint(0x000000FF),
r_uint(0x0000FF00),
r_uint(0x00FF0000),
r_uint(0xFF000000))
fmt = surface.c_format
color = RSDL.MapRGB(fmt, 255, 0, 0)
RSDL.FillRect(surface, lltype.nullptr(RSDL.Rect), color)
paintrect = RSDL_helper.mallocrect(75, 0, 150, 50)
dstrect = lltype.malloc(RSDL.Rect, flavor='raw')
try:
color = RSDL.MapRGB(fmt, 255, 128, 0)
RSDL.FillRect(surface, paintrect, color)
rffi.setintfield(dstrect, 'c_x', 10)
rffi.setintfield(dstrect, 'c_y', 10)
rffi.setintfield(dstrect, 'c_w', 150)
rffi.setintfield(dstrect, 'c_h', 50)
RSDL.BlitSurface(surface, lltype.nullptr(RSDL.Rect), self.screen, dstrect)
RSDL.Flip(self.screen)
finally:
lltype.free(dstrect, flavor='raw')
lltype.free(paintrect, flavor='raw')
RSDL.FreeSurface(surface)
self.check("Half Red/Orange rectangle(150px * 50px) at the top left, 10 pixels from the border")
def draw(self, surf):
#if self._braneRect:
fmt = surf.c_format
b = int(self._brane * 6)
if b > 255: b = 255
elif b < 0: b = 0
color = RSDL.MapRGB(fmt, 0, 0, b)
RSDL.FillRect(surf, self._braneRect, color)
RSDL.FillRect(surf, self._groupRect, self._group_color)
if self._draw_spike:
RSDL.FillRect(surf, self._spikeRect, self._sdl_colors['white'])
else:
RSDL.FillRect(surf, self._spikeRect,
color) #self._sdl_colors['black'])
self._draw_spike = False
def test_mousemove(self):
if not self.is_interactive:
py.test.skip("interactive test only")
print
print "Move the Mouse up and down:"
print " Use Escape to quit."
event = lltype.malloc(RSDL.Event, flavor="raw")
directions = [False]*4
try:
while True:
ok = RSDL.WaitEvent(event)
assert rffi.cast(lltype.Signed, ok) == 1
c_type = rffi.getintfield(event, "c_type")
if c_type == RSDL.MOUSEMOTION:
m = rffi.cast(RSDL.MouseMotionEventPtr, event)
assert rffi.getintfield(m, "c_x") >= 0
assert rffi.getintfield(m, "c_y") >= 0
print rffi.getintfield(m, "c_xrel")
directions[0] |= rffi.getintfield(m, "c_xrel")>0
directions[1] |= rffi.getintfield(m, "c_xrel")<0
directions[2] |= rffi.getintfield(m, "c_yrel")>0
directions[3] |= rffi.getintfield(m, "c_yrel")<0
if False not in directions:
break
elif c_type == RSDL.KEYUP:
p = rffi.cast(RSDL.KeyboardEventPtr, event)
if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE:
print " test manually aborted"
py.test.fail(" mousemovement test aborted")
break
finally:
lltype.free(event, flavor='raw')
def test_load_image():
for filename in ["demo.jpg", "demo.png"]:
image = RIMG.Load(os.path.join(autopath.this_dir, filename))
assert image
assert rffi.getintfield(image, 'c_w') == 17
assert rffi.getintfield(image, 'c_h') == 23
RSDL.FreeSurface(image)
def setup_draw(self, format, braneRect, groupRect, spikeRect, colors):
self._braneRect = braneRect
self._groupRect = groupRect
self._spikeRect = spikeRect
self._sdl_colors = colors
r, g, b = self._color
self._group_color = RSDL.MapRGB(format, int(r * 255), int(g * 255),
int(b * 255))
def test_bit_pattern(self):
HEIGHT = WIDTH = 10
fmt = self.screen.c_format
white = RSDL.MapRGB(fmt, 255, 255, 255)
black = RSDL.MapRGB(fmt, 0, 0, 0)
RSDL.LockSurface(self.screen)
for i in xrange(WIDTH):
for j in xrange(HEIGHT):
k = j*WIDTH + i
if k % 2:
c = white
else:
c = black
RSDL_helper.set_pixel(self.screen, i, j, c)
RSDL.UnlockSurface(self.screen)
RSDL.Flip(self.screen)
self.check("Upper left corner 10x10 field with vertical black/white stripes")
def test_set_color_key(self):
# prepare
fillrect = RSDL_helper.mallocrect(10, 10, 30, 30)
RSDL.FillRect(self.src_surf, fillrect, self.blue)
lltype.free(fillrect, flavor='raw')
assert RSDL.SetColorKey(self.src_surf, RSDL.SRCCOLORKEY,
self.blue) == 0
# draw
RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 0, 0)
# check
for position, color in (((0, 0), self.red), ((10, 10), self.black),
((20, 20), self.black), ((40, 40), self.red)):
fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0],
position[1])
assert fetched_color == color
def test_load_wav():
if RMix.OpenAudio(22050, RSDL.AUDIO_S16LSB, 2, 1024) != 0:
error = rffi.charp2str(RSDL.GetError())
raise Exception(error)
filename = rffi.str2charp('applause.wav')
RMix.LoadWAV(filename)
rffi.free_charp(filename)
RMix.CloseAudio()
def test_play_wav():
if RMix.OpenAudio(22050, RSDL.AUDIO_S16LSB, 2, 1024) != 0:
error = rffi.charp2str(RSDL.GetError())
raise Exception(error)
filename = rffi.str2charp('applause.wav')
applause = RMix.LoadWAV(filename)
rffi.free_charp(filename)
RMix.PlayChannel(-1, applause, -1)
time.sleep(1)
RMix.CloseAudio()
def update(self, event):
# fetch the event from sdl
ok = RSDL.WaitEvent(event)
assert rffi.cast(lltype.Signed, ok) == 1
type = rffi.getintfield(event, 'c_type')
if type == RSDL.KEYDOWN:
self.create_called_key()
self.on_key_down()
elif type == RSDL.KEYUP:
self.create_called_key()
self.on_key_up()
def entry_point(argv=None):
RSDL.Init(RSDL.INIT_VIDEO) >= 0
screen = RSDL.SetVideoMode(WIDTH, HEIGHT, 32, 0)
event = lltype.malloc(RSDL.Event, flavor='raw')
paintpattern = 0
try:
while True:
ok = RSDL.WaitEvent(event)
assert rffi.cast(lltype.Signed, ok) == 1
c_type = rffi.getintfield(event, 'c_type')
if c_type == RSDL.KEYDOWN:
p = rffi.cast(RSDL.KeyboardEventPtr, event)
if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE:
print 'Escape key'
break
paintpattern += 1
update_screen(screen, paintpattern)
finally:
lltype.free(event, flavor='raw')
return 0
def loop(self):
self._active = True
fmt = self.screen.c_format
RSDL.FillRect(self.screen, lltype.nullptr(RSDL.Rect), self.ColorGrey)
layers = self._layers
neurons = self._neurons
pulse_layers = self._pulse_layers
screen = self.screen
loops = 0
now = start = float(time.time())
while self._active:
#Bjitdriver.can_enter_jit( layers=layers, neurons=neurons, pulse_layers=pulse_layers, loops=loops )
#Bjitdriver.jit_merge_point( layers=layers, neurons=neurons, pulse_layers=pulse_layers, loops=loops)
now = float(time.time())
self._fps = loops / float(now - start)
for i, lay in enumerate(self._layers):
if self._pulse_layers[i] and False:
#print 'pulse layer: %s neurons: %s ' %(i, len(lay))
for n in lay:
if random() * random() > 0.8:
n.spike(now)
for i, col in enumerate(self._columns):
if self._pulse_columns[i]:
for n in col:
n.spike(now)
for n in self._neurons:
n.iterate()
n.draw(self.screen)
#r,w,x = rpoll.select( [self._stdin], [], [], 1 ) # wait
rl, wl, xl = rpoll.select([0], [], [], 0.000001) # wait
if rl:
cmd = self._stdin.readline().strip('\n').strip(' ')
self.do_command(cmd)
loops += 1
self._iterations = loops
#print loops # can not always print in mainloop, then select can never read from stdin
RSDL.Flip(self.screen)
#self._fps = float(time.time()) - now
#return loops
return 0
def get_rgb(color, format):
rgb = lltype.malloc(rffi.CArray(RSDL.Uint8), 3, flavor='raw')
try:
RSDL.GetRGB(color, format, rffi.ptradd(rgb, 0), rffi.ptradd(rgb, 1),
rffi.ptradd(rgb, 2))
r = rffi.cast(lltype.Signed, rgb[0])
g = rffi.cast(lltype.Signed, rgb[1])
b = rffi.cast(lltype.Signed, rgb[2])
result = r, g, b
finally:
lltype.free(rgb, flavor='raw')
return result
def mainLoop(self):
self.reset()
self.is_running = True
try:
while self.is_running and self.handle_events():
self.emulate(constants.GAMEBOY_CLOCK >> 2)
time.sleep(10 / 1000)
except:
self.is_running = False
lltype.free(self.event, flavor='raw')
RSDL.Quit()
self.handle_execution_error()
return 0
def update_screen(screen, paintpattern):
fmt = screen.c_format
white = RSDL.MapRGB(fmt, 255, 255, 255)
black = RSDL.MapRGB(fmt, 0, 0, 0)
RSDL.LockSurface(screen)
pattern[paintpattern % pl](screen, black, white)
RSDL.UnlockSurface(screen)
RSDL.Flip(screen)
RSDL.Delay(10)
def test_set_alpha(self):
# prepare
assert RSDL.SetAlpha(self.src_surf, RSDL.SRCALPHA, 128) == 0
# draw
RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 10, 10)
RSDL_helper.blit_complete_surface(self.src_surf, self.dst_surf, 20, 20)
# check
for position, color in (
((0, 0), (0, 0, 0)), # no rect
((10, 10), (127, 0, 0)), # one rect
((20, 20), (191, 0, 0)) # two overlapping rects
):
fetched_color = RSDL_helper.get_pixel(self.dst_surf, position[0],
position[1])
assert RSDL_helper.get_rgb(fetched_color,
self.dst_surf.c_format) == color
def setup_method(self, meth):
self.dst_surf = RSDL.CreateRGBSurface(0, 300, 300, 32,
r_uint(0x000000FF),
r_uint(0x0000FF00),
r_uint(0x00FF0000),
r_uint(0x00000000))
self.src_surf = RSDL.CreateRGBSurface(0, 50, 50, 32,
r_uint(0x000000FF),
r_uint(0x0000FF00),
r_uint(0x00FF0000),
r_uint(0x00000000))
fmt = self.src_surf.c_format
self.black = RSDL.MapRGB(fmt, 0, 0, 0)
self.red = RSDL.MapRGB(fmt, 255, 0, 0)
self.blue = RSDL.MapRGB(fmt, 0, 0, 255)
RSDL.FillRect(self.src_surf, lltype.nullptr(RSDL.Rect), self.red)
def test_mousebutton_wheel(self):
if not self.is_interactive:
py.test.skip("interactive test only")
print
print "Press the given MouseButtons:"
print " Use Escape to pass tests."
event_tests = [("left button", RSDL.BUTTON_LEFT),
("middle button", RSDL.BUTTON_MIDDLE),
("right button", RSDL.BUTTON_RIGHT),
("scroll up", RSDL.BUTTON_WHEELUP),
("scroll down", RSDL.BUTTON_WHEELDOWN)]
test_success = []
event = lltype.malloc(RSDL.Event, flavor='raw')
try:
for button_test in event_tests:
print " press %s:" % button_test[0]
while True:
ok = RSDL.WaitEvent(event)
assert rffi.cast(lltype.Signed, ok) == 1
c_type = rffi.getintfield(event, 'c_type')
if c_type == RSDL.MOUSEBUTTONDOWN:
pass
elif c_type == RSDL.MOUSEBUTTONUP:
b = rffi.cast(RSDL.MouseButtonEventPtr, event)
if rffi.getintfield(b, 'c_button') == button_test[1]:
test_success.append(True)
break
elif c_type == RSDL.KEYUP:
p = rffi.cast(RSDL.KeyboardEventPtr, event)
if rffi.getintfield(p.c_keysym, 'c_sym') == RSDL.K_ESCAPE:
test_success.append(False)
print " manually aborted"
break
#break
if False in test_success:
py.test.fail("")
finally:
lltype.free(event, flavor='raw')
def test_get_keyname():
assert RSDL.Init(RSDL.INIT_VIDEO) >= 0
assert RSDL.GetKeyName(RSDL.K_PLUS)[0] == '+'
assert RSDL.GetKeyName(RSDL.K_RIGHTPAREN)[0] == ')'
assert RSDL.GetKeyName(RSDL.K_z)[0] == 'z'
def test_caption(self):
RSDL.WM_SetCaption("Hello World!", "Hello World!")
self.check('The window caption is "Hello World!"')
def test_show_hide_cursor(self):
RSDL.ShowCursor(RSDL.DISABLE)
self.check("Is the cursor hidden? ")
RSDL.ShowCursor(RSDL.ENABLE)
self.check("Is the cursor shown? ")
def test_delay_getticks():
assert RSDL.Init(RSDL.INIT_VIDEO) >= 0
RSDL.Delay(10)
i = RSDL.GetTicks()
assert i >= 10
RSDL.Quit()
def test_sdl_init():
assert RSDL.Init(RSDL.INIT_VIDEO) >= 0
RSDL.Quit()
def teardown_method(self, meth):
RSDL.Quit()
