← Back to branch summary

~ubuntu-branches/ubuntu/utopic/libavg/utopic

« back to all changes in this revision

Viewing changes to src/test/PythonTest.py

  • Committer: Bazaar Package Importer
  • Author(s): Torsten Werner
  • Date: 2010-05-02 23:50:04 UTC
  • mfrom: (1.1.4 upstream) (2.1.6 sid)
  • Revision ID: james.westby@ubuntu.com-20100502235004-i6u38zelbi2k12ii
Tags: 1.0.1-1
http://bugs.debian.org/565512
http://bugs.debian.org/575551
* new upstream release (Closes: #565512)
* Remove patches that have been merged upstream.
* Add a patch that avoids building tests by default.
* Remove .py extension from two more scripts in /usr/bin .
* Add 2 example files to /usr/share/doc/python-libavg/examples/ .
* Describe a workaround for bug #579937 in README.Debian.
* Install debian/libavg.pth into /usr/share/pyshared/ .
  (Closes: #575551)
* Add get-orig-source target to debian/rules.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/test/PythonTest.py
1
1
#!/usr/bin/python
2
2
# -*- coding: utf-8 -*-
 
3
# libavg - Media Playback Engine.
 
4
# Copyright (C) 2003-2008 Ulrich von Zadow
 
5
#
 
6
# This library is free software; you can redistribute it and/or
 
7
# modify it under the terms of the GNU Lesser General Public
 
8
# License as published by the Free Software Foundation; either
 
9
# version 2 of the License, or (at your option) any later version.
 
10
#
 
11
# This library is distributed in the hope that it will be useful,
 
12
# but WITHOUT ANY WARRANTY; without even the implied warranty of
 
13
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
14
# Lesser General Public License for more details.
 
15
#
 
16
# You should have received a copy of the GNU Lesser General Public
 
17
# License along with this library; if not, write to the Free Software
 
18
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
19
#
 
20
# Current versions can be found at www.libavg.de
 
21
#
 
22
 
3
23
import unittest
4
24
 
5
25
import sys, platform
27
47
class PythonTestCase(AVGTestCase):
28
48
    def __init__(self, testFuncName):
29
49
        AVGTestCase.__init__(self, testFuncName, 24)
30
 
    def testAnimType(self, createAnimFunc, imgBaseName):
 
50
 
 
51
    def testAnimType(self, curAnim, imgBaseName):
31
52
        def onStop():
32
53
            self.__onStopCalled = True
 
54
 
33
55
        def startAnim():
34
56
            self.__onStopCalled = False
35
57
            node = Player.getElementByID("test")
36
 
            self.__runningAnim = self.__createAnimFunc(node, onStop)
 
58
            self.__anim.start()
 
59
 
 
60
        def startKeepAttr():
 
61
            node = Player.getElementByID("test")
 
62
            node.x = 25
 
63
            self.__anim.start(keepAttr=True)
 
64
 
37
65
        def abortAnim():
38
 
            self.__runningAnim.abort()
39
 
        self.__createAnimFunc = createAnimFunc
 
66
            self.__anim.abort()
 
67
 
 
68
        self.__anim = curAnim
 
69
        self.__anim.setHandler(onStop, None)
40
70
        self.__onStopCalled = False
41
 
        anim.init(avg)
42
71
        Player.setFakeFPS(10)
43
 
        self.start("image.avg",
 
72
        self.start(None,
44
73
                (startAnim,
45
74
                 lambda: self.compareImage(imgBaseName+"1", False),
46
75
                 lambda: self.assert_(anim.getNumRunningAnims() == 1),
47
76
                 None,
48
77
                 None,
49
78
                 lambda: self.assert_(self.__onStopCalled),
50
 
                 lambda: self.assert_(self.__runningAnim.isDone),
 
79
                 lambda: self.assert_(self.__anim.isDone),
51
80
                 lambda: self.compareImage(imgBaseName+"2", False),
52
81
                 lambda: self.assert_(Player.getElementByID("test").x == 100),
53
82
                 startAnim,
55
84
                 abortAnim,
56
85
                 lambda: self.assert_(anim.getNumRunningAnims() == 0),
57
86
                 lambda: self.compareImage(imgBaseName+"3", False),
58
 
                 lambda: self.assert_(self.__runningAnim.isDone),
 
87
                 lambda: self.assert_(self.__anim.isDone),
59
88
                 None,
60
89
                 lambda: self.assert_(not(self.__onStopCalled)),
61
90
                 startAnim,
62
 
                 startAnim,
63
 
                 lambda: self.assert_(anim.getNumRunningAnims() == 1)
 
91
                 startKeepAttr,
 
92
                 lambda: self.assert_(anim.getNumRunningAnims() == 1),
 
93
                 abortAnim
64
94
                ))
65
 
        self.__runningAnim = None
 
95
        self.__anim = None
66
96
 
67
97
    def testLinearAnim(self):
68
 
        def createAnim(node, onStop):
69
 
            return anim.LinearAnim(node, "x", 200, 0, 100, False, onStop)
70
 
        self.testAnimType(createAnim, "testLinearAnim")
 
98
        Player.loadFile("image.avg")
 
99
        node = Player.getElementByID("test")
 
100
        curAnim = anim.LinearAnim(node, "x", 200, 0, 100, False)
 
101
        self.testAnimType(curAnim, "testLinearAnim")
 
102
 
 
103
    def testLinearAnimZeroDuration(self):
 
104
        def onStop():
 
105
            self.__onStopCalled = True
 
106
 
 
107
        def startAnim():
 
108
            self.__onStopCalled = False
 
109
            node = Player.getElementByID("test")
 
110
            self.__anim.start()
 
111
 
 
112
        Player.loadFile("image.avg")
 
113
        node = Player.getElementByID("test")
 
114
        self.__anim = anim.LinearAnim(node, "x", 0, 0, 100, False)
 
115
        self.__anim.setHandler(onStop, None)
 
116
        self.__onStopCalled = False
 
117
        Player.setFakeFPS(10)
 
118
        self.start(None,
 
119
                (startAnim,
 
120
                 lambda: self.compareImage("testLinearAnimZeroDuration1", False),
 
121
                 lambda: self.assert_(anim.getNumRunningAnims() == 0),
 
122
                 lambda: self.assert_(self.__onStopCalled),
 
123
                 lambda: self.assert_(self.__anim.isDone)
 
124
                ))
 
125
        self.__anim = None
71
126
 
72
127
    def testEaseInOutAnim(self):
73
 
        def createAnim(node, onStop):
74
 
            return anim.EaseInOutAnim(node, "x", 400, 0, 100, 100, 100,
75
 
                    False, onStop)
76
 
        self.testAnimType(createAnim, "testEaseInOutAnim")
 
128
        Player.loadFile("image.avg")
 
129
        node = Player.getElementByID("test")
 
130
        curAnim = anim.EaseInOutAnim(node, "x", 400, 0, 100, 100, 100, False)
 
131
        self.testAnimType(curAnim, "testEaseInOutAnim")
77
132
 
78
133
    def testSplineAnim(self):
79
 
        def createAnim(node, onStop):
80
 
            return anim.SplineAnim(node, "x", 300, 0, 0, 100, 0,
81
 
                    False, onStop)
82
 
        self.testAnimType(createAnim, "testSplineAnim")
 
134
        Player.loadFile("image.avg")
 
135
        node = Player.getElementByID("test")
 
136
        curAnim = anim.SplineAnim(node, "x", 300, 0, 0, 100, 0, False)
 
137
        self.testAnimType(curAnim, "testSplineAnim")
83
138
 
84
139
    def testContinuousAnim(self):
85
140
        def onStart():
92
147
            Player.setTimeout(800,stopAnim)
93
148
            Player.setTimeout(900,lambda:self.compareImage("testContAnim4", False))
94
149
            Player.setTimeout(1000,Player.stop)
 
150
 
95
151
        def startAnim():
96
152
            node=Player.getElementByID("mainimg")
97
153
            self.anim=anim.ContinuousAnim(node,"angle",0,1,0)
 
154
            self.anim.start()
 
155
 
98
156
        def startAnim2():
99
157
            node=Player.getElementByID("nestedimg1")
100
158
            self.anim2=anim.ContinuousAnim(node,"width",0,50,0)
 
159
            self.anim2.start()
 
160
 
101
161
        def startAnim3():
102
162
            node=Player.getElementByID("nestedimg2")
103
163
            self.anim3=anim.ContinuousAnim(node,"x",0,50,0)
 
164
            self.anim3.start()
 
165
 
104
166
        def stopAnim():
105
167
            self.anim.abort()
106
168
            self.anim2.abort()
115
177
        Player.setTimeout(1, onStart)
116
178
        Player.play()
117
179
 
 
180
    def testWaitAnim(self):
 
181
        def animStopped():
 
182
            self.__endCalled = True
 
183
 
 
184
        def startAnim():
 
185
            self.anim = anim.WaitAnim(200, animStopped, False)
 
186
            self.anim.start()
 
187
 
 
188
        anim.init(avg)
 
189
        Player.setFakeFPS(10)
 
190
        self.__endCalled = False
 
191
        self.start("image.avg",
 
192
                (startAnim, 
 
193
                 lambda: self.assert_(not(self.anim.isDone())),
 
194
                 None,
 
195
                 None,
 
196
                 lambda: self.assert_(self.anim.isDone()),
 
197
                 lambda: self.assert_(self.__endCalled)
 
198
                ))
 
199
 
 
200
    def testStateAnim(self):
 
201
        def state2Callback():
 
202
            self.__state2CallbackCalled = True
 
203
 
 
204
        def makeAnim():
 
205
            node = Player.getElementByID("test")
 
206
            self.anim = anim.StateAnim(
 
207
                    {"STATE1": anim.LinearAnim(node, "x", 200, 64, 128),
 
208
                     "STATE2": anim.LinearAnim(node, "x", 200, 128, 64),
 
209
                     "STATE3": anim.WaitAnim()},
 
210
                    {"STATE1": anim.AnimTransition("STATE2", state2Callback),
 
211
                     "STATE2": anim.AnimTransition("STATE3")})
 
212
        anim.init(avg)
 
213
        Player.setFakeFPS(10)
 
214
        self.__state2CallbackCalled = False
 
215
        self.start("image.avg",
 
216
                (makeAnim,
 
217
                 lambda: self.compareImage("testStateAnim1", False),
 
218
                 lambda: self.anim.setState("STATE1"),
 
219
                 None,
 
220
                 lambda: self.compareImage("testStateAnim2", False),
 
221
                 lambda: self.anim.getState() == "STATE2",
 
222
                 lambda: self.compareImage("testStateAnim3", False),
 
223
                 lambda: self.assert_(self.__state2CallbackCalled),
 
224
                 lambda: self.anim.getState() == "STATE3",
 
225
                 lambda: self.compareImage("testStateAnim4", False),
 
226
                 lambda: self.anim.setState("STATE1"),
 
227
                 lambda: self.assert_(anim.getNumRunningAnims() == 1),
 
228
                 lambda: self.compareImage("testStateAnim5", False)
 
229
                ))
 
230
 
 
231
    def testParallelAnim(self):
 
232
        def animStopped():
 
233
            self.__endCalled = True
 
234
 
 
235
        def startAnim():
 
236
            node0 = Player.getElementByID("mainimg")
 
237
            node1 = Player.getElementByID("test")
 
238
            node2 = Player.getElementByID("test1")
 
239
            self.anim = anim.ParallelAnim(
 
240
                    [ anim.LinearAnim(node0, "x", 200, 0, 2),
 
241
                      anim.SplineAnim(node1, "x", 400, 0, 40, 0, 0),
 
242
                      anim.EaseInOutAnim(node2, "x", 300, 129, 99, 100, 100)
 
243
                    ], animStopped)
 
244
            self.anim.start()
 
245
        
 
246
        anim.init(avg)
 
247
        self.__endCalled = False
 
248
        Player.setFakeFPS(10)
 
249
        self.start("image.avg",
 
250
                (startAnim,
 
251
                 lambda: self.assert_(anim.getNumRunningAnims() == 3),
 
252
                 lambda: self.assert_(not(self.anim.isDone())),
 
253
                 lambda: self.compareImage("testParallelAnims1", False),
 
254
                 None,
 
255
                 None,
 
256
                 lambda: self.compareImage("testParallelAnims2", False),
 
257
                 lambda: self.assert_(self.anim.isDone()),
 
258
                 lambda: self.assert_(self.__endCalled)
 
259
                ))
 
260
 
118
261
    def testDraggable(self):
119
262
        def onDragStart(event):
120
263
            self.__dragStartCalled = True
 
264
        
121
265
        def onDragEnd(event):
122
266
            self.__dragEndCalled = True
 
267
        
123
268
        def startDrag():
124
269
            Helper.fakeMouseEvent(avg.CURSORDOWN, True, False, False, 140, 40, 1)
 
270
        
125
271
        def move():
126
272
            Helper.fakeMouseEvent(avg.CURSORMOTION, True, False, False, 150, 50, 1)
 
273
        
127
274
        def stop():
128
275
            Helper.fakeMouseEvent(avg.CURSORUP, True, False, False, 140, 40, 1)
 
276
        
129
277
        self.__dragEndCalled = False
130
278
        self.__dragStartCalled = False
131
279
        Helper = Player.getTestHelper()    
132
280
        Player.loadFile("image.avg")
133
281
        draggable.init(avg)
134
 
        dragger = draggable.Draggable(Player.getElementByID("testhue"),
 
282
        dragger = draggable.Draggable(Player.getElementByID("test1"),
135
283
                onDragStart, onDragEnd)
136
284
        dragger.enable()
137
285
        self.start(None,
151
299
    def testButton(self):
152
300
        def onClick(event):
153
301
            self.__clicked = True
 
302
        
154
303
        def createButton():
155
304
            buttonNode = Player.getElementByID("button") 
156
305
            self.button = button.Button(buttonNode, onClick)
157
306
            buttonNode.getChild(4).opacity = 0
 
307
        
158
308
        def down():
159
309
            self.__sendEvent(avg.CURSORDOWN, 0, 0)
 
310
        
160
311
        def out():
161
312
            self.__sendEvent(avg.CURSORMOTION, 0, 50)
 
313
        
162
314
        def upOutside():
163
315
            self.__sendEvent(avg.CURSORUP, 0, 50)
 
316
        
164
317
        def over():
165
318
            self.__sendEvent(avg.CURSORMOTION, 0, 0)
 
319
        
166
320
        def upInside():
167
321
            self.__sendEvent(avg.CURSORUP, 0, 0)
 
322
        
168
323
        def disable():
169
324
            self.button.setDisabled(True)
170
325
            self.__clicked = False
 
326
        
171
327
        self.__clicked = False
172
328
        button.init(avg)
173
329
        self.start("ButtonTest.avg",
205
361
    def testCheckbox(self):
206
362
        def createCheckbox():
207
363
            self.checkbox = button.Checkbox(Player.getElementByID("button"))
 
364
        
208
365
        def down():
209
366
            self.__sendEvent(avg.CURSORDOWN, 0, 0)
 
367
        
210
368
        def up():
211
369
            self.__sendEvent(avg.CURSORUP, 0, 0)
 
370
        
212
371
        def out():
213
372
            self.__sendEvent(avg.CURSORMOTION, 0, 50)
 
373
        
214
374
        button.init(avg)
215
375
        self.start("ButtonTest.avg",
216
376
                (createCheckbox,
229
389
               ))
230
390
 
231
391
    def testTextArea(self):
232
 
        def createTextAreaSet():
233
 
            textarea.init(avg)
234
 
            self.ctx1 = textarea.FocusContext()
235
 
            self.ctx2 = textarea.FocusContext()
236
 
            
237
 
            self.ta1 = textarea.TextArea(Player.getElementByID('placeholder'), self.ctx1, id='ta1')
238
 
            self.ta1.setStyle(font='Bitstream Vera Sans', variant="Roman", size=4, multiline=True)
239
 
            self.ta1.setText("Lorem ipsum")
240
 
 
241
 
            self.ta2 = textarea.TextArea(Player.getElementByID('placeholder_2'), self.ctx1, id='ta2')
242
 
            self.ta2.setStyle(font='Bitstream Vera Sans', variant="Roman", size=2, multiline=False)
243
 
 
244
 
            self.ta3 = textarea.TextArea(Player.getElementByID('placeholder_3'), self.ctx2, '1x1_white.png', True, id='ta3')
245
 
            self.ta3.setStyle(font='Bitstream Vera Sans', variant="Roman", size=3, multiline=True)
246
 
            
247
 
            textarea.setActiveFocusContext(self.ctx1)
 
392
        def setup():
 
393
            self.ta1 = textarea.TextArea(Player.getElementByID('ph1'), id='ta1')
 
394
            self.ta1.setStyle(font='Bitstream Vera Sans', variant='Roman',
 
395
                fontsize=16, multiline=True, color='FFFFFF')
 
396
            self.ta1.setText('Lorem ipsum')
 
397
            self.ta1.setFocus(True) # TODO: REMOVE
 
398
 
 
399
            self.ta2 = textarea.TextArea(Player.getElementByID('ph2'), id='ta2')
 
400
            self.ta2.setStyle(font='Bitstream Vera Sans', variant='Roman',
 
401
                fontsize=14, multiline=False, color='FFFFFF')
 
402
            self.ta2.setText('sit dolor')
 
403
            self.ta2.setFocus(True) # TODO: REMOVE
248
404
            
249
405
        def setAndCheck(ta, text):
250
406
            ta.setText(text)
251
407
            self.assert_(ta.getText() == text)
 
408
        
 
409
        def clear(ta):
 
410
            ta.onKeyDown(textarea.KEYCODE_FORMFEED)
 
411
            self.assert_(ta.getText() == '')
 
412
        
 
413
        def testUnicode():
 
414
            self.ta1.setText(u'some ùnìcöde')
 
415
            self.ta1.onKeyDown(textarea.KEYCODES_BACKSPACE[0])
 
416
            self.assert_(self.ta1.getText() == u'some ùnìcöd')
 
417
            self.ta1.onKeyDown(textarea.KEYCODES_BACKSPACE[1])
 
418
            self.ta1.onKeyDown(textarea.KEYCODES_BACKSPACE[0])
 
419
            self.assert_(self.ta1.getText() == u'some ùnìc')
 
420
            self.ta1.onKeyDown(ord(u'Ä'))
 
421
            self.assert_(self.ta1.getText() == u'some ùnìcÄ')
 
422
        
 
423
        def testSpecialChars():
 
424
            clear(self.ta1)
 
425
            self.ta1.onKeyDown(ord(u'&'))
 
426
            self.ta1.onKeyDown(textarea.KEYCODES_BACKSPACE[0])
 
427
            self.assert_(self.ta1.getText() == '')
 
428
        
252
429
        def checkSingleLine():
253
430
            text = ''
254
431
            self.ta2.setText('')
255
432
            while True:
256
 
                print text, self.ta2.getText()
257
 
                self.assert_(len(text) < 60)
258
 
                self.ctx1.keyCharPressed('X')
259
 
                text = text + 'X'
 
433
                self.assert_(len(text) < 20)
 
434
                self.ta2.onKeyDown(ord(u'A'))
 
435
                text = text + 'A'
260
436
                if text != self.ta2.getText():
 
437
                    self.assert_(len(text) == 16)
261
438
                    break
262
 
        def clearPage():
263
 
            self.ctx1.keyUCodePressed(textarea.KEYCODE_FORMFEED)
264
 
            self.assert_(self.ta2.getText() == '')
265
 
        def longText():
266
 
            textarea.setActiveFocusContext(self.ctx2)
267
 
            text = u'''
268
 
Lorem ipsum dolor sit amet, consectetuer adipiscing elit. Donec massa nunc, pretium sed,
269
 
sagittis mollis, dignissim vitae, erat. Vestibulum mattis, erat nec pulvinar lacìnia,
270
 
'''
271
 
            self.ta3.setText(text)
272
 
            self.assert_(len(self.ta3.getText()) == len(text)-1)
273
 
        def clickFocus():
274
 
            textarea.setActiveFocusContext(self.ctx1)
275
 
            self.ctx1.cycleFocus()
276
 
            self.__sendEvent(avg.CURSORDOWN, 20, 20)
277
 
            self.__sendEvent(avg.CURSORUP, 20, 20)
278
 
        def testClickFocus():
279
 
            self.assert_(self.ctx1.getFocused())
280
 
            self.assert_(self.ctx1.getFocused().getID() == 'ta1')
281
 
            self.ctx1.keyUCodePressed(textarea.KEYCODE_FORMFEED)
282
 
            self.ctx1.keyCharPressed('X')
283
 
            self.assert_(self.ta1.getText() == 'X')
284
 
        def testUnicode():
285
 
            self.ta1.setText(u'some ùnìcöde')
286
 
            self.ctx1.keyUCodePressed(textarea.KEYCODES_BACKSPACE[0])
287
 
            self.assert_(self.ta1.getText() == u'some ùnìcöd')
288
 
            self.ctx1.keyUCodePressed(textarea.KEYCODES_BACKSPACE[1])
289
 
            self.ctx1.keyUCodePressed(textarea.KEYCODES_BACKSPACE[0])
290
 
            self.assert_(self.ta1.getText() == u'some ùnìc')
291
 
            self.ctx1.keyCharPressed('ò')
292
 
            self.assert_(self.ta1.getText() == u'some ùnìcò')
293
 
        def testSpecialChars():
294
 
            self.ctx1.clear()
295
 
            self.ctx1.keyCharPressed('&')
296
 
            self.ctx1.keyUCodePressed(textarea.KEYCODES_BACKSPACE[0])
297
 
            self.assert_(self.ta1.getText() == '')
298
 
        def sendKeyEvents():
299
 
            Helper = Player.getTestHelper()
300
 
            Helper.fakeKeyEvent(avg.KEYDOWN, 65, 65, "A", 65, 0)
301
 
            Helper.fakeKeyEvent(avg.KEYUP, 65, 65, "A", 65, 0)
302
 
            Helper.fakeKeyEvent(avg.KEYDOWN, 59, 59, ";", 242, 0)
303
 
            Helper.fakeKeyEvent(avg.KEYUP, 59, 59, ";", 242, 0)
304
 
        def testKeyEvents():
305
 
            self.assert_(self.ta1.getText() == u'Aò')
 
439
            
 
440
        Player.loadString("""
 
441
        <avg width="160" height="120">
 
442
            <div id="ph1" x="2" y="2" width="156" height="96"/>
 
443
            <div id="ph2" x="2" y="100" width="156" height="18"/>
 
444
        </avg>
 
445
        """)
306
446
        
 
447
        import time
307
448
        textarea.init(avg, False)
308
 
        self.start("TextAreaTest.avg",
309
 
               (createTextAreaSet,
310
 
               lambda: self.assert_(self.ta1.getText() != 'Lorem Ipsum'),
311
 
               lambda: setAndCheck(self.ta1, ''),
312
 
               lambda: setAndCheck(self.ta2, 'Lorem Ipsum'),
313
 
               checkSingleLine,
314
 
               clearPage,
315
 
#               longText,
316
 
               clickFocus,
317
 
               testClickFocus,
318
 
               testUnicode,
319
 
               testSpecialChars,
320
 
               sendKeyEvents,
321
 
               testKeyEvents
 
449
        self.start(None,
 
450
               (setup,
 
451
                lambda: self.assert_(self.ta1.getText() == 'Lorem ipsum'),
 
452
                lambda: setAndCheck(self.ta1, ''),
 
453
                lambda: setAndCheck(self.ta2, 'Lorem Ipsum'),
 
454
                testUnicode,
 
455
                lambda: self.compareImage("testTextArea1", True),
 
456
                testSpecialChars,
 
457
                checkSingleLine,
 
458
                lambda: self.compareImage("testTextArea2", True),
322
459
               ))
323
460
 
 
461
    def testFocusContext(self):
 
462
       def setup():
 
463
           textarea.init(avg)
 
464
           self.ctx1 = textarea.FocusContext()
 
465
           self.ctx2 = textarea.FocusContext()
 
466
 
 
467
           self.ta1 = textarea.TextArea(Player.getElementByID('ph1'),
 
468
               self.ctx1, id='ta1')
 
469
           self.ta1.setStyle(font='Bitstream Vera Sans', variant='Roman',
 
470
               fontsize=16, multiline=True, color='FFFFFF')
 
471
           self.ta1.setText('Lorem ipsum')
 
472
 
 
473
           self.ta2 = textarea.TextArea(Player.getElementByID('ph2'),
 
474
               self.ctx1, id='ta2')
 
475
           self.ta2.setStyle(font='Bitstream Vera Sans', variant='Roman',
 
476
               fontsize=14, multiline=False, color='FFFFFF')
 
477
           self.ta2.setText('dolor')
 
478
 
 
479
           self.ta3 = textarea.TextArea(Player.getElementByID('ph3'),
 
480
               self.ctx2, disableMouseFocus=True, id='ta3')
 
481
           self.ta3.setStyle(font='Bitstream Vera Sans', variant='Roman',
 
482
               fontsize=14, multiline=True, color='FFFFFF')
 
483
           self.ta3.setText('dolor sit amet')
 
484
 
 
485
           textarea.setActiveFocusContext(self.ctx1)
 
486
 
 
487
       def writeChar():
 
488
           helper = Player.getTestHelper()
 
489
           helper.fakeKeyEvent(avg.KEYDOWN, 65, 65, "A", 65, 0)
 
490
           helper.fakeKeyEvent(avg.KEYUP, 65, 65, "A", 65, 0)
 
491
           helper.fakeKeyEvent(avg.KEYDOWN, 66, 66, "B", 66, 0)
 
492
           helper.fakeKeyEvent(avg.KEYUP, 66, 66, "B", 66, 0)
 
493
           helper.fakeKeyEvent(avg.KEYDOWN, 67, 67, "C", 67, 0)
 
494
           helper.fakeKeyEvent(avg.KEYUP, 67, 67, "C", 67, 0)
 
495
 
 
496
       def switchFocus():
 
497
           self.ctx1.cycleFocus()
 
498
 
 
499
       def clearFocused():
 
500
           self.ctx1.clear()
 
501
 
 
502
       def clickForFocus():
 
503
           self.__sendEvent(avg.CURSORDOWN, 20, 70)
 
504
           self.__sendEvent(avg.CURSORUP, 20, 70)
 
505
 
 
506
       Player.loadString("""
 
507
       <avg width="160" height="120">
 
508
           <div id="ph1" x="2" y="2" width="156" height="54"/>
 
509
           <div id="ph2" x="2" y="58" width="76" height="54"/>
 
510
           <div id="ph3" x="80" y="58" width="76" height="54">
 
511
               <image href="1x1_white.png" width="76" height="54"/>
 
512
           </div>
 
513
       </avg>
 
514
       """)
 
515
       self.start(None,
 
516
               (setup,
 
517
                lambda: self.compareImage("testFocusContext1", True),
 
518
                writeChar,
 
519
                lambda: self.compareImage("testFocusContext2", True),
 
520
                switchFocus,
 
521
                writeChar,
 
522
                lambda: self.compareImage("testFocusContext3", True),
 
523
                switchFocus,
 
524
                clearFocused,
 
525
                lambda: self.compareImage("testFocusContext4", True),
 
526
                clickForFocus,
 
527
                clearFocused,
 
528
                lambda: self.compareImage("testFocusContext5", True),
 
529
              ))
 
530
 
324
531
    def __sendEvent(self, type, x, y):
325
532
        Helper = Player.getTestHelper()
326
533
        Helper.fakeMouseEvent(type, True, False, False, x, y, 1)
327
534
 
328
535
 
329
 
def pythonTestSuite():
330
 
    suite = unittest.TestSuite()
331
 
    suite.addTest(PythonTestCase("testLinearAnim"))
332
 
    suite.addTest(PythonTestCase("testEaseInOutAnim"))
333
 
    suite.addTest(PythonTestCase("testSplineAnim"))
334
 
    suite.addTest(PythonTestCase("testContinuousAnim"))
335
 
    suite.addTest(PythonTestCase("testDraggable"))
336
 
    suite.addTest(PythonTestCase("testButton"))
337
 
    suite.addTest(PythonTestCase("testCheckbox"))
338
 
    suite.addTest(PythonTestCase("testTextArea"))
339
 
    return suite
 
536
def pythonTestSuite (tests):
 
537
    availableTests = (
 
538
        "testLinearAnim",
 
539
        "testLinearAnimZeroDuration",
 
540
        "testEaseInOutAnim",
 
541
        "testSplineAnim",
 
542
        "testContinuousAnim",
 
543
        "testWaitAnim",
 
544
        "testParallelAnim",
 
545
        "testStateAnim",
 
546
        "testDraggable",
 
547
        "testButton",
 
548
        "testCheckbox",
 
549
        "testTextArea",
 
550
        "testFocusContext",
 
551
        )
 
552
    return AVGTestSuite (availableTests, PythonTestCase, tests)
340
553
 
341
554
Player = avg.Player.get()
 
555
anim.init(avg)