# -*- coding: utf-8 -*-
# libavg - Media Playback Engine.
# Copyright (C) 2003-2014 Ulrich von Zadow
#
# This library is free software; you can redistribute it and/or
# modify it under the terms of the GNU Lesser General Public
# License as published by the Free Software Foundation; either
# version 2 of the License, or (at your option) any later version.
#
# This library is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# Lesser General Public License for more details.
#
# You should have received a copy of the GNU Lesser General Public
# License along with this library; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
#
# Current versions can be found at www.libavg.de
#
import math
import threading
from libavg import avg, player
from testcase import *
class PlayerTestCase(AVGTestCase):
def __init__(self, testFuncName):
AVGTestCase.__init__(self, testFuncName)
def testPoint(self):
def testHash():
ptMap = {}
ptMap[avg.Point2D(0,0)] = 0
ptMap[avg.Point2D(1,0)] = 1
ptMap[avg.Point2D(0,0)] = 2
self.assertEqual(len(ptMap), 2)
self.assertEqual(ptMap[avg.Point2D(0,0)], 2)
def testToTupleConversion():
pt = avg.Point2D(10, 20)
tpl = tuple(pt)
self.assertEqual(pt.x, tpl[0])
self.assertEqual(pt.y, tpl[1])
def testFromTupleConversion():
tpl = (15, 20)
pt = avg.Point2D(tpl)
self.assertEqual(pt.x, tpl[0])
self.assertEqual(pt.y, tpl[1])
pt = avg.Point2D()
self.assertEqual(pt, avg.Point2D(0,0))
pt = avg.Point2D(10, 20)
self.assertEqual(pt[0], pt.x)
self.assertEqual(pt[1], pt.y)
pt = avg.Point2D(10, 10)
self.assertEqual(pt, avg.Point2D(10, 10))
self.assertEqual(pt, (10, 10))
self.assertEqual(pt, avg.Point2D([10, 10]))
self.assertNotEqual(pt, avg.Point2D(11, 10))
self.assertEqual(str(pt), "(10,10)")
pt2 = eval(repr(pt))
self.assertEqual(pt2, pt)
testHash()
testFromTupleConversion()
testToTupleConversion()
self.assertAlmostEqual(avg.Point2D(10,0).getNormalized(), avg.Point2D(1,0))
self.assertAlmostEqual(pt.getRotated(math.pi, (5,5)), avg.Point2D(0,0))
self.assertEqual(-pt, (-10, -10))
self.assertEqual(pt-(10,0), (0,10))
self.assertEqual(pt+(10,0), (20,10))
self.assertEqual(pt*2, (20,20))
self.assertEqual(2*pt, (20,20))
pt.x = 21
pt.y = 23
self.assertEqual(pt, avg.Point2D(21, 23))
pt.x -= 11
pt.y -= 13
pt += avg.Point2D(10, 10)
self.assertEqual(pt, avg.Point2D(20, 20))
pt -= avg.Point2D(6, 6)
self.assertEqual(pt, avg.Point2D(14, 14))
self.assertNotEqual(pt, avg.Point2D(13, 13))
pt = pt/2.
self.assertEqual(pt, avg.Point2D(7, 7))
pt = avg.Point2D((10, 10))
self.assertEqual(pt, (10, 10))
self.assertEqual(len(pt), 2)
self.assertEqual(pt[0], pt.x)
self.assertEqual(pt[1], pt.y)
self.assertException(lambda: pt[2])
self.assertAlmostEqual(avg.Point2D(10,0), avg.Point2D.fromPolar(0,10))
self.assertException(avg.Point2D(0,0).getNormalized)
self.assertException(lambda: avg.Point2D(0,))
self.assertException(lambda: avg.Point2D(0,1,2))
for point in ((10,0), (0,10), (-10,0), (0,-10)):
pt = avg.Point2D(point)
angle = pt.getAngle()
norm = pt.getNorm()
self.assertAlmostEqual(pt, avg.Point2D.fromPolar(angle,norm))
def testBasics(self):
def getFramerate():
framerate = player.getEffectiveFramerate()
self.assert_(framerate > 0)
def invalidCreateNode():
avg.ImageNode(1, 2, 3)
player.showCursor(0)
player.showCursor(1)
root = self.loadEmptyScene()
avg.ImageNode(href="rgb24-65x65.png", parent=root)
self.assertException(invalidCreateNode)
self.start(False,
(getFramerate,
lambda: self.compareImage("testbasics"),
lambda: player.setGamma(0.3, 0.3, 0.3),
lambda: player.showCursor(0),
lambda: player.showCursor(1),
))
def testColorParse(self):
def setColor(colorName):
node.color = colorName
node = avg.LineNode(pos1=(0.5, 0), pos2=(0.5, 50), color="FF0000")
setColor("ff00ff")
self.assertException(lambda: setColor("foo"))
self.assertException(lambda: setColor("ff00f"))
self.assertException(lambda: setColor("ff00ffx"))
self.assertException(lambda: setColor("ff00fx"))
def testFakeTime(self):
def checkTime():
self.assertEqual(player.getFrameTime(), 50)
self.assertEqual(player.getFrameDuration(), 50)
self.assertEqual(player.getEffectiveFramerate(), 20)
self.loadEmptyScene()
player.setFakeFPS(20)
self.start(False,
(checkTime,
))
def testDivResize(self):
def checkSize (w, h):
self.assertEqual(node.width, w)
self.assertEqual(node.height, h)
self.assertEqual(node.size, (w,h))
def setSize (size):
node.size = size
def setWidth (w):
node.width = w
def setHeight (h):
node.height = h
self.__initDefaultScene()
node = player.getElementByID('nestedavg')
self.start(False,
(lambda: checkSize(128, 32),
lambda: setSize((14,15)),
lambda: checkSize(14,15),
lambda: setWidth(23),
lambda: checkSize(23,15),
lambda: setHeight(22),
lambda: checkSize(23,22),
))
def testRotate(self):
def onOuterDown(Event):
self.onOuterDownCalled = True
def fakeRotate():
player.getElementByID("outer").angle += 0.1
player.getElementByID("inner").angle -= 0.1
def testCoordConversions():
innerNode = player.getElementByID("inner")
relPos = innerNode.getRelPos((90, 80))
self.assertAlmostEqual(relPos, (10, 10))
outerNode = player.getElementByID("outer")
relPos = outerNode.getRelPos((90, 80))
self.assertAlmostEqual(relPos[0], 12.332806394528092)
self.assertAlmostEqual(relPos[1], 6.9211188716194592)
absPos = outerNode.getAbsPos(relPos)
self.assertAlmostEqual(absPos, (90, 80))
self.assertEqual(outerNode.getElementByPos((10, 10)), innerNode)
self.assertEqual(outerNode.getElementByPos((0, 10)), outerNode)
self.assertEqual(outerNode.getElementByPos((-10, -110)), None)
def disableCrop():
player.getElementByID("outer").crop = False
player.getElementByID("inner").crop = False
self.__initDefaultRotateScene()
player.getElementByID("outer").subscribe(avg.Node.CURSOR_DOWN, onOuterDown)
self.onOuterDownCalled = False
self.start(False,
(lambda: self.compareImage("testRotate1"),
testCoordConversions,
fakeRotate,
lambda: self.compareImage("testRotate1a"),
lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 85, 70),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 85, 70),
lambda: self.assert_(not(self.onOuterDownCalled)),
lambda: self._sendMouseEvent(avg.Event.CURSOR_DOWN, 85, 75),
lambda: self._sendMouseEvent(avg.Event.CURSOR_UP, 85, 75),
lambda: self.assert_(self.onOuterDownCalled),
disableCrop,
lambda: self.compareImage("testRotate1b"),
))
def testRotate2(self):
root = self.loadEmptyScene()
div1 = avg.DivNode(pos=(80,0), size=(160,120), pivot=(0,0), angle=1.57,
parent=root)
avg.ImageNode(size=(16,16), href="rgb24-65x65.png", parent=div1)
div2 = avg.DivNode(pos=(40,0), size=(110,80), pivot=(0,0), angle=1.57,
crop=True, parent=div1)
avg.ImageNode(pos=(0,0), size=(16,16), href="rgb24-65x65.png", parent=div2)
avg.ImageNode(pos=(30,-6), size=(16,16), href="rgb24-65x65.png", parent=div2)
self.start(False, [lambda: self.compareImage("testRotate2")])
def testRotatePivot(self):
def setPivot (pos):
node.pivot = pos
def addPivot (offset):
node.pivot += offset
root = self.loadEmptyScene()
node = avg.DivNode(pos=(80,0), size=(160,120), pivot=(0,0), angle=1.57,
crop=True, parent=root)
div = avg.DivNode(pos=(40,-20), size=(160,120), pivot=(0,0), angle=0.79,
crop=True, parent=node)
avg.ImageNode(pos=(-10,-10), size=(128,128), href="rgb24-65x65.png", parent=div)
avg.ImageNode(pos=(0,10), size=(32,32), href="rgb24-65x65.png", parent=node)
self.start(False,
(lambda: self.compareImage("testRotatePivot1"),
lambda: setPivot((10, 10)),
lambda: self.compareImage("testRotatePivot2"),
lambda: addPivot((-8, 0)),
lambda: self.compareImage("testRotatePivot3"),
))
def testOpacity(self):
root = self.loadEmptyScene()
avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", opacity=0.5, parent=root)
avg.RectNode(pos=(0,64), size=(64,64), opacity=0.5, fillopacity=0.5,
fillcolor="FF0000", strokewidth=2, parent=root)
div = avg.DivNode(pos=(80,0), opacity=0.5, parent=root)
avg.ImageNode(pos=(0,0), href="rgb24-65x65.png", parent=div)
avg.RectNode(pos=(0,64), size=(64,64), opacity=1, fillopacity=1,
fillcolor="FF0000", strokewidth=2, parent=div)
self.start(False,
(lambda: self.compareImage("testOpacity"),
))
def testOutlines(self):
root = self.__initDefaultRotateScene()
root.elementoutlinecolor = "FFFFFF"
innerDiv = player.getElementByID("inner")
innerDiv.size = (0, 0)
innerDiv.getChild(0).elementoutlinecolor = "00FF00"
self.start(False, [lambda: self.compareImage("testOutlines")])
def testWordsOutlines(self):
root = self.loadEmptyScene()
root.elementoutlinecolor = "FFFFFF"
avg.WordsNode(pos=(40,40), alignment="center", text="test", parent=root)
self.start(True, [lambda: self.compareImage("testWordsOutlines")])
def testError(self):
self.initDefaultImageScene()
player.setTimeout(1, lambda: undefinedFunction)
player.setTimeout(50, player.stop)
try:
player.play()
except NameError:
self.assert_(1)
else:
self.assert_(0)
def testExceptionInTimeout(self):
def throwException():
raise ZeroDivisionError
try:
self.initDefaultImageScene()
self.start(False, [throwException])
except ZeroDivisionError:
self.assert_(1)
else:
self.assert_(0)
def testInvalidImageFilename(self):
def activateNode():
div.active = 1
root = self.loadEmptyScene()
div = avg.DivNode(active=False, parent=root)
avg.ImageNode(href="filedoesntexist.png", parent=div)
self.start(False, [activateNode])
def testInvalidVideoFilename(self):
def tryplay():
assertException(lambda: video.play())
root = self.loadEmptyScene()
video = avg.VideoNode(href="filedoesntexist.avi", parent=root)
self.start(False,
(lambda: tryplay,
lambda: video.stop()
))
def testTimeouts(self):
class TestException(Exception):
pass
def timeout1():
player.clearInterval(self.timeout1ID)
player.clearInterval(self.timeout2ID)
self.timeout1called = True
def timeout2():
self.timeout2called = True
def onFrame():
self.numOnFramesCalled += 1
if self.numOnFramesCalled == 3:
player.clearInterval(self.intervalID)
def wait():
pass
def throwException():
raise TestException
def initException():
self.timeout3ID = player.setTimeout(0, throwException)
def setupTimeouts():
self.timeout1ID = player.setTimeout(0, timeout1)
self.timeout2ID = player.setTimeout(1, timeout2)
self.intervalID = player.setOnFrameHandler(onFrame)
self.timeout1called = False
self.timeout2called = False
self.__exceptionThrown = False
self.numOnFramesCalled = 0
try:
self.initDefaultImageScene()
self.start(False,
(setupTimeouts,
None,
lambda: self.assert_(self.timeout1called),
lambda: self.assert_(not(self.timeout2called)),
lambda: self.assert_(self.numOnFramesCalled == 3),
lambda: initException(),
lambda: self.delay(10),
))
except TestException:
self.__exceptionThrown = True
self.assert_(self.__exceptionThrown)
player.clearInterval(self.timeout3ID)
def testCallFromThread(self):
def onAsyncCall():
self.asyncCalled = True
def threadFunc():
player.setTimeout(0, onAsyncCall)
def startThread():
self.thread = threading.Thread(target=threadFunc)
self.thread.start()
self.initDefaultImageScene()
self.asyncCalled = False
player.setFakeFPS(-1)
self.start(False,
(startThread,
lambda: self.thread.join(),
None,
lambda: self.assert_(self.asyncCalled),
))
def testAVGFile(self):
player.loadFile("image.avg")
self.start(False,
(lambda: self.compareImage("testAVGFile"),
))
self.assertException(lambda: player.loadFile("filedoesntexist.avg"))
def testBroken(self):
def testBrokenString(string):
self.assertException(lambda: player.loadString(string))
# This isn't xml
testBrokenString("""
xxx