1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
|
import sys
import pytest
from ctypes import c_int, cast, POINTER
from sdl2 import SDL_Init, SDL_Quit, SDL_QuitSubSystem, SDL_INIT_VIDEO
from sdl2 import rect, keyboard, scancode, keycode, video
byteify = lambda x: x.encode("utf-8")
class TestSDLKeyboard(object):
__tags__ = ["sdl"]
@classmethod
def setup_class(cls):
if SDL_Init(SDL_INIT_VIDEO) != 0:
raise pytest.skip('Video subsystem not supported')
@classmethod
def teardown_class(cls):
SDL_QuitSubSystem(SDL_INIT_VIDEO)
SDL_Quit()
def test_SDL_Keysym(self):
keysym = keyboard.SDL_Keysym()
assert keysym.scancode == 0
assert keysym.sym == 0
assert keysym.mod == 0
keysym = keyboard.SDL_Keysym(1, 2, 3, ord("b"))
assert keysym.scancode == 1
assert keysym.sym == 2
assert keysym.mod == 3
uval = "\u0220"
if sys.version_info[0] < 3:
uval = unichr(8224)
keysym = keyboard.SDL_Keysym(17, 32, 88, ord(uval))
assert keysym.scancode == 17
assert keysym.sym == 32
assert keysym.mod == 88
@pytest.mark.skipif(sys.platform == "darwin", reason="crashes on OS X")
def test_SDL_GetKeyboardFocus(self):
# window = keyboard.SDL_GetKeyboardFocus()
# TODO: x
# self.assertEqual(window, None)
rwin = video.SDL_CreateWindow(b"test", 10, 10, 10, 10, 0)
window = keyboard.SDL_GetKeyboardFocus()
if window:
assert video.SDL_GetWindowID(window) == video.SDL_GetWindowID(rwin)
video.SDL_DestroyWindow(rwin)
window = keyboard.SDL_GetKeyboardFocus()
# TODO: x
# self.assertEqual(window, None)
def test_SDL_GetKeyboardState(self):
states = (c_int * scancode.SDL_NUM_SCANCODES)()
keyboard.SDL_GetKeyboardState(cast(states, POINTER(c_int)))
assert len(states) == scancode.SDL_NUM_SCANCODES
# TODO: x
# for state in states:
# self.assertEqual(state, 0)
def test_SDL_GetKeyFromName(self):
for x in range(26): # a-z
key = keyboard.SDL_GetKeyFromName(byteify(chr(x + 97)))
assert key == x + 97
for x in range(10):
key = keyboard.SDL_GetKeyFromName(("%d" % x).encode("utf-8"))
assert key == 48 + x
val = keyboard.SDL_GetKeyFromName(byteify(repr(self)))
assert val == keycode.SDLK_UNKNOWN
def test_SDL_GetKeyFromScancode(self):
p = 0
for x in (scancode.SDL_SCANCODE_A,
scancode.SDL_SCANCODE_B,
scancode.SDL_SCANCODE_C):
key = keyboard.SDL_GetKeyFromScancode(x)
assert key == p + 97
p += 1
p = 0
for x in range(scancode.SDL_SCANCODE_1, scancode.SDL_SCANCODE_0):
key = keyboard.SDL_GetKeyFromScancode(x)
assert key == 49 + p
p += 1
def test_SDL_GetKeyName(self):
x = 65 # SDL maps everything against upper-case letters
for key in range(ord('a'), ord('z')):
ch = chr(x)
name = keyboard.SDL_GetKeyName(key)
assert name == byteify(ch)
x += 1
def test_SDL_GetSetModState(self):
initial = keyboard.SDL_GetModState()
for state in(keycode.KMOD_NUM | keycode.KMOD_CAPS | keycode.KMOD_MODE,
keycode.KMOD_NUM | keycode.KMOD_CAPS,
keycode.KMOD_CAPS):
keyboard.SDL_SetModState(state)
assert keyboard.SDL_GetModState() == state
state = keycode.KMOD_NUM
keyboard.SDL_SetModState(state)
assert keyboard.SDL_GetModState() == state
keyboard.SDL_SetModState(initial)
assert keyboard.SDL_GetModState() == initial
def test_SDL_GetScancodeFromKey(self):
codes = range(scancode.SDL_SCANCODE_1, scancode.SDL_SCANCODE_0)
xoff = 0
for key in range(ord('1'), ord('0')):
code = keyboard.SDL_GetScancodeFromKey(key)
assert code == codes[xoff]
xoff += 1
key = keyboard.SDL_GetScancodeFromKey(477)
assert key == scancode.SDL_SCANCODE_UNKNOWN
def test_SDL_GetScancodeFromName(self):
codes = range(scancode.SDL_SCANCODE_A, scancode.SDL_SCANCODE_Z)
xoff = 0
for key in range(ord('a'), ord('z')):
ch = chr(key)
code = keyboard.SDL_GetScancodeFromName(byteify(ch))
assert code == codes[xoff]
xoff += 1
key = keyboard.SDL_GetScancodeFromName(b"")
assert key == scancode.SDL_SCANCODE_UNKNOWN
key = keyboard.SDL_GetScancodeFromName(None)
assert key == scancode.SDL_SCANCODE_UNKNOWN
key = keyboard.SDL_GetScancodeFromName(b"Test")
assert key == scancode.SDL_SCANCODE_UNKNOWN
key = keyboard.SDL_GetScancodeFromName(byteify(repr(self)))
assert key == scancode.SDL_SCANCODE_UNKNOWN
def test_SDL_GetScancodeName(self):
names = range(ord('A'), ord('Z'))
xoff = 0
for code in range(scancode.SDL_SCANCODE_A, scancode.SDL_SCANCODE_Z):
name = keyboard.SDL_GetScancodeName(code)
assert name == byteify(chr(names[xoff]))
xoff += 1
name = keyboard.SDL_GetScancodeName(0)
assert name == b""
# self.assertRaises(ValueError, keyboard.SDL_GetScancodeName, -22)
# self.assertRaises(ValueError, keyboard.SDL_GetScancodeName,
# scancode.SDL_NUM_SCANCODES)
def test_SDL_SetTextInputRect(self):
# TODO: this test is a bit pointless
coords = [(0, 0, 0, 0), (-10, -70, 3, 6), (10, 10, 10, 10)]
for x, y, w, h in coords:
r = rect.SDL_Rect(x, y, w, h)
keyboard.SDL_SetTextInputRect(r)
keyboard.SDL_SetTextInputRect(rect.SDL_Rect())
@pytest.mark.skip("not implemented")
def test_SDL_StartTextInput(self):
keyboard.SDL_StartTextInput()
@pytest.mark.skip("not implemented")
def test_SDL_StopTextInput(self):
keyboard.SDL_StopTextInput()
|
