summaryrefslogtreecommitdiff
path: root/src/test/AnimTest.py
diff options
context:
space:
mode:
Diffstat (limited to 'src/test/AnimTest.py')
-rw-r--r--src/test/AnimTest.py512
1 files changed, 512 insertions, 0 deletions
diff --git a/src/test/AnimTest.py b/src/test/AnimTest.py
new file mode 100644
index 0000000..4079b6a
--- /dev/null
+++ b/src/test/AnimTest.py
@@ -0,0 +1,512 @@
+#!/usr/bin/python
+# -*- 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
+#
+
+from libavg import avg, player
+from testcase import *
+
+class AnimTestCase(AVGTestCase):
+ def __init__(self, testFuncName):
+ AVGTestCase.__init__(self, testFuncName)
+
+ def initScene(self):
+ root = self.loadEmptyScene()
+ self.__node = avg.ImageNode(id="test", pos=(64,30), href="rgb24-65x65.png",
+ parent=root)
+ player.setFakeFPS(10)
+
+ def testAnimType(self, curAnim, imgBaseName):
+ def onStop():
+ self.__onStopCalled = True
+
+ def startAnim():
+ self.__onStopCalled = False
+ self.__anim.start()
+
+ def startKeepAttr():
+ self.__node.x = 32
+ self.__anim.start(True)
+
+ def abortAnim():
+ self.__anim.abort()
+
+ self.__anim = curAnim
+ self.__anim.setStopCallback(onStop)
+ self.__onStopCalled = False
+ self.assertException(lambda: self.__anim.start())
+ self.start(False,
+ (startAnim,
+ lambda: self.compareImage(imgBaseName+"1"),
+ lambda: self.compareImage(imgBaseName+"2"),
+ lambda: self.compareImage(imgBaseName+"3"),
+ lambda: self.assert_(self.__onStopCalled),
+ lambda: self.assert_(not(self.__anim.isRunning())),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ lambda: self.compareImage(imgBaseName+"4"),
+ lambda: self.assertEqual(self.__node.x, 100),
+ startAnim,
+ lambda: self.compareImage(imgBaseName+"1"),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
+ abortAnim,
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ lambda: self.compareImage(imgBaseName+"5"),
+ lambda: self.assert_(not(self.__anim.isRunning())),
+ None,
+ lambda: self.assert_(self.__onStopCalled),
+ startKeepAttr,
+ lambda: self.compareImage(imgBaseName+"6"),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 1)
+ ))
+ self.__anim = None
+
+ def testLinearAnim(self):
+ self.initScene()
+ curAnim = avg.LinearAnim(self.__node, "x", 300, 0, 100)
+ self.testAnimType(curAnim, "testLinearAnimC")
+
+ def testAnimRegistry(self):
+ def on1Stop():
+ self.__onStopCalled = True
+
+ def on2Start():
+ self.__onStopBeforeOnStart = self.__onStopCalled
+
+ self.initScene()
+ sameNode = player.getElementByID("test")
+ anim1 = avg.LinearAnim(self.__node, "x", 500, 0, 100,
+ False, None, on1Stop)
+ anim2 = avg.LinearAnim(sameNode, "x", 300, 0, 100,
+ False, on2Start)
+ self.__onStopCalled = False
+ self.__onStopBeforeOnStart = False
+ self.start(False,
+ (lambda: anim1.start(),
+ lambda: self.assert_(not(self.__onStopCalled)),
+ lambda: anim2.start(),
+ lambda: self.assert_(self.__onStopBeforeOnStart),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 1)
+ ))
+ anim1 = None
+ anim2 = None
+
+ def testFadeIn(self):
+ def onStop():
+ self.__onStopCalled = True
+
+ self.initScene()
+ self.__node.opacity=0.5
+ self.__onStopCalled = False
+ self.start(False,
+ (lambda: avg.fadeIn(self.__node, 200, 1, onStop),
+ lambda: self.compareImage("testFadeIn1"),
+ lambda: self.compareImage("testFadeIn2"),
+ lambda: self.compareImage("testFadeIn3"),
+ lambda: self.assert_(self.__onStopCalled),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0)
+ ))
+ self.__anim = None
+
+ def testFadeOut(self):
+ def onStop():
+ self.__onStopCalled = True
+
+ self.initScene()
+ self.__node.opacity=0.5
+ self.__onStopCalled = False
+ self.start(False,
+ (lambda: avg.fadeOut(self.__node, 200, onStop),
+ lambda: self.compareImage("testFadeOut1"),
+ lambda: self.compareImage("testFadeOut2"),
+ lambda: self.compareImage("testFadeOut3"),
+ lambda: self.assert_(self.__onStopCalled),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0)
+ ))
+ self.__anim = None
+
+ def testNonExistentAttributeAnim(self):
+ self.initScene()
+ self.assertException(lambda: avg.LinearAnim(self.__node, "foo", 0, 0, 0, False))
+ self.assertException(lambda: avg.LinearAnim(None, "x", 0, 0, 0, False))
+
+ def testLinearAnimZeroDuration(self):
+ def onStop():
+ self.__onStopCalled = True
+
+ def startAnim():
+ self.__onStopCalled = False
+ self.__anim.start()
+
+ self.initScene()
+ self.__anim = avg.LinearAnim(self.__node, "x", 0, 0, 100, False, None, onStop)
+ self.__onStopCalled = False
+ self.start(False,
+ (startAnim,
+ lambda: self.compareImage("testLinearAnimZeroDurationC1"),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ lambda: self.assert_(self.__onStopCalled),
+ lambda: self.assert_(not(self.__anim.isRunning()))
+ ))
+ self.__anim = None
+
+ def testPingPongStopAnim(self):
+ def forth():
+ anim = avg.LinearAnim(self.__node, 'pos', 100, (50, 100),
+ (100, 100), False, None, back)
+ anim.start()
+
+ def back():
+ anim = avg.LinearAnim(self.__node, 'pos', 100, (100, 100),
+ (50, 100), False, None, forth)
+ anim.start()
+
+ self.initScene()
+ self.start(False,
+ (forth,
+ lambda: self.delay(300),
+ ))
+
+ def testPointAnim(self):
+ self._testPointAnim(
+ startPos=(0, 0),
+ endPos=(100, 40),
+ keepAttrPos=(50, 20),
+ startPosImgSrc="testPointAnim1",
+ endPosImgSrc="testPointAnim2",
+ keepAttrPosImgSrc="testPointAnim3")
+
+ def testXPosPointAnim(self):
+ self._testPointAnim(
+ startPos=(0, 0),
+ endPos=(80, 0),
+ keepAttrPos=(40, 0),
+ startPosImgSrc="testXPosPointAnim1",
+ endPosImgSrc="testXPosPointAnim2",
+ keepAttrPosImgSrc="testXPosPointAnim3")
+
+ def testYPosPointAnim(self):
+ self._testPointAnim(
+ startPos=(0, 0),
+ endPos=(0, 80),
+ keepAttrPos=(0, 40),
+ startPosImgSrc="testYPosPointAnim1",
+ endPosImgSrc="testYPosPointAnim2",
+ keepAttrPosImgSrc="testYPosPointAnim3")
+
+ def testIntAnim(self):
+ self.initScene()
+ self.__doubleAnim = avg.LinearAnim(self.__node, "x", 300, 0, 100, True)
+ self.__pointAnim = avg.LinearAnim(self.__node, "pos", 200, avg.Point2D(0,0),
+ avg.Point2D(100,40), True)
+ self.start(False,
+ (self.__doubleAnim.start,
+ lambda: self.delay(100),
+ lambda: self.compareImage("testIntAnim1"),
+ self.__doubleAnim.abort,
+ self.__pointAnim.start,
+ lambda: self.delay(100),
+ lambda: self.compareImage("testIntAnim2"),
+ ))
+
+ def testEaseInOutAnim(self):
+ self.initScene()
+ curAnim = avg.EaseInOutAnim(self.__node, "x", 300, 0, 100, 100, 100, False)
+ self.testAnimType(curAnim, "testEaseInOutAnimC")
+
+ def testContinuousAnim(self):
+ def startAnim():
+ self.__animStarted = True
+
+ def stopAnim():
+ self.__animStopped = True
+
+ def reset():
+ self.__animStarted = False
+ self.__animStopped = False
+
+ self.initScene()
+ self.__anim = avg.ContinuousAnim(self.__node, "angle", 0, 2*math.pi,
+ False, startAnim, stopAnim)
+ self.__linearAnim = avg.LinearAnim(self.__node, "angle", 1000, math.pi, math.pi)
+
+ self.__animStarted = False
+ self.__animStopped = False
+ self.start(False,
+ (self.__anim.start,
+ lambda: self.assert_(self.__animStarted),
+ lambda: self.compareImage("testContinuousAnim1"),
+ self.__anim.abort,
+ lambda: self.assert_(self.__animStopped),
+ reset,
+ self.__anim.start,
+ self.__linearAnim.start,
+ lambda: self.assert_(self.__animStopped),
+ lambda: self.compareImage("testContinuousAnim2"),
+ self.__linearAnim.abort,
+ ))
+
+ def testWaitAnim(self):
+ def animStopped():
+ self.__endCalled = True
+
+ def startAnim():
+ self.anim = avg.WaitAnim(200, animStopped, None)
+ self.anim.start()
+
+ self.initScene()
+ self.__endCalled = False
+ self.start(False,
+ (startAnim,
+ lambda: self.assert_(self.anim.isRunning()),
+ lambda: self.delay(200),
+ lambda: self.assert_(not(self.anim.isRunning())),
+ lambda: self.assert_(self.__endCalled)
+ ))
+
+ def testParallelAnim(self):
+ def animStopped():
+ self.__endCalled = True
+
+ def startFireForgetAnim():
+ avg.ParallelAnim(
+ [ avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
+ avg.LinearAnim(self.nodes[1], "x", 200, 0, 120)
+ ]).start()
+
+ def startAnim():
+ self.anim = avg.ParallelAnim(
+ [ avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
+ avg.LinearAnim(self.nodes[1], "x", 400, 0, 120),
+ avg.EaseInOutAnim(self.nodes[2], "x", 400, 0, 120, 100, 100)
+ ], None, animStopped)
+ self.__endCalled = False
+ self.anim.start()
+
+ def startTimedAnim():
+ self.anim = avg.ParallelAnim(
+ [ avg.LinearAnim(self.nodes[0], "x", 200, 0, 60),
+ avg.LinearAnim(self.nodes[1], "x", 400, 0, 120),
+ ], None, animStopped, 200)
+ self.__endCalled = False
+ self.anim.start()
+
+ def abortAnim():
+ self.anim.abort()
+
+ def deleteAnim():
+ self.anim = None
+
+ root = self.loadEmptyScene()
+ self.nodes = []
+ for i in range(3):
+ node = avg.ImageNode(id=str(i), pos=(64, i*20), href="rgb24-64x64.png")
+ root.appendChild(node)
+ self.nodes.append(node)
+ player.setFakeFPS(10)
+ self.__endCalled = False
+ self.start(False,
+ (startFireForgetAnim,
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 2),
+ None,
+ startAnim,
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 3),
+ lambda: self.compareImage("testParallelAnimC1"),
+ lambda: self.assert_(self.anim.isRunning()),
+ lambda: self.delay(200),
+ lambda: self.assert_(not(self.anim.isRunning())),
+ lambda: self.compareImage("testParallelAnimC2"),
+ lambda: self.assert_(self.__endCalled),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ startAnim,
+ abortAnim,
+ lambda: self.compareImage("testParallelAnimC3"),
+ lambda: self.assert_(self.__endCalled),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ startTimedAnim,
+ lambda: self.delay(200),
+ lambda: self.assert_(self.__endCalled),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ startAnim
+ ))
+ self.nodes = []
+
+ def testParallelAnimRegistry(self):
+ def makeAnims():
+ avg.ParallelAnim(
+ [ avg.LinearAnim(self.__node, "x", 200, 0, 60),
+ avg.LinearAnim(self.__node, "y", 200, 0, 120)
+ ]).start()
+
+ avg.LinearAnim(self.__node, "x", 300, 0, 100, False, None).start()
+
+ self.initScene()
+ self.start(False,
+ (makeAnims,
+ None
+ ))
+
+ def testStateAnim(self):
+ def state1StopCallback():
+ self.__state1StopCallbackCalled = True
+
+ def state2StartCallback():
+ if self.__state1StopCallbackCalled:
+ self.__stop1Start2CallbackOrder = True
+ self.__state2StartCallbackCalled = True
+
+ def makeAnim():
+ self.anim = avg.StateAnim(
+ [avg.AnimState("STATE1", avg.LinearAnim(self.__node, "x", 200,
+ 0, 100, False, None, state1StopCallback), "STATE2"),
+ avg.AnimState("STATE2", avg.LinearAnim(self.__node, "x", 200,
+ 100, 50, False, state2StartCallback), "STATE3"),
+ avg.AnimState("STATE3", avg.WaitAnim())
+ ])
+# self.anim.setDebug(True)
+
+ def killAnim():
+ self.anim = None
+
+ self.initScene()
+ self.__state1StopCallbackCalled = False
+ self.__state2StartCallbackCalled = False
+ self.__stop1Start2CallbackOrder = False
+ self.start(False,
+ (makeAnim,
+ lambda: self.compareImage("testStateAnimC1"),
+ lambda: self.anim.setState("STATE1"),
+ None,
+ lambda: self.compareImage("testStateAnimC2"),
+ lambda: self.assertEqual(self.anim.getState(), "STATE2"),
+ lambda: self.compareImage("testStateAnimC3"),
+ lambda: self.assert_(self.__state1StopCallbackCalled),
+ lambda: self.assert_(self.__state2StartCallbackCalled),
+ lambda: self.assert_(self.__stop1Start2CallbackOrder),
+ lambda: self.assertEqual(self.anim.getState(), "STATE3"),
+ lambda: self.compareImage("testStateAnimC4"),
+ lambda: self.anim.setState("STATE1"),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
+ lambda: self.compareImage("testStateAnimC5"),
+ killAnim,
+# lambda: player.getTestHelper().dumpObjects()
+ ))
+
+ def testNonNodeAttrAnim(self):
+ class GenericClass(object):
+ def __init__(self):
+ self.numberValue = 0
+ self.pointValue = avg.Point2D(0.0, 0.0)
+
+ def on1Stop():
+ self.__onStopCalled = True
+
+ def on2Start():
+ self.__onStopBeforeOnStart = self.__onStopCalled
+
+ self.loadEmptyScene()
+ player.setFakeFPS(10)
+ genericObject1 = GenericClass()
+ genericObject2 = genericObject1
+ genericObject3 = GenericClass()
+ anim1 = avg.LinearAnim(genericObject1, "numberValue", 1000, 0, 100,
+ False, None, on1Stop)
+ anim2 = avg.LinearAnim(genericObject2, "numberValue", 1200, 0, 200,
+ False, on2Start)
+ anim3 = avg.LinearAnim(genericObject1, "pointValue", 800, (0, 0), (100, 200))
+ anim4 = avg.LinearAnim(genericObject3, "numberValue", 400, 0, 42)
+ self.__onStopCalled = False
+ self.__onStopBeforeOnStart = False
+ self.start(False,
+ (lambda: anim1.start(),
+ lambda: self.assert_(anim1.isRunning()),
+ lambda: self.assert_(not(self.__onStopCalled)),
+ lambda: anim2.start(),
+ lambda: self.assert_(self.__onStopBeforeOnStart),
+ lambda: self.assert_(not(anim1.isRunning())),
+ lambda: self.assert_(anim2.isRunning()),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 1),
+ lambda: anim3.start(),
+ lambda: self.assert_(anim2.isRunning()),
+ lambda: self.assert_(anim3.isRunning()),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 2),
+ lambda: anim4.start(),
+ lambda: self.assert_(anim4.isRunning()),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 3),
+ lambda: self.delay(200),
+ lambda: self.assertEqual(avg.getNumRunningAnims(), 0),
+ lambda: self.assert_(genericObject1.numberValue == 200),
+ lambda: self.assert_(genericObject2.pointValue == (100, 200)),
+ lambda: self.assert_(genericObject3.numberValue == 42)
+ ))
+ anim1 = None
+ anim2 = None
+ anim3 = None
+ anim4 = None
+ genericObject1 = None
+ genericObject2 = None
+ genericObject3 = None
+
+
+ def _testPointAnim(self, startPos, endPos, keepAttrPos, startPosImgSrc, endPosImgSrc,
+ keepAttrPosImgSrc):
+ def startAnim():
+ self.__anim.start()
+
+ def startKeepAttr():
+ self.__node.pos = keepAttrPos
+ self.__anim.start(True)
+
+ self.initScene()
+ self.__anim = avg.LinearAnim(self.__node, "pos", 200, avg.Point2D(startPos),
+ avg.Point2D(endPos), False)
+ self.start(False,
+ (startAnim,
+ lambda: self.compareImage(startPosImgSrc),
+ lambda: self.compareImage(endPosImgSrc),
+ None,
+ lambda: self.assert_(not(self.__anim.isRunning())),
+ startKeepAttr,
+ lambda: self.compareImage(keepAttrPosImgSrc),
+ ))
+
+
+def animTestSuite(tests):
+ availableTests = (
+ "testLinearAnim",
+ "testAnimRegistry",
+ "testFadeIn",
+ "testFadeOut",
+ "testNonExistentAttributeAnim",
+ "testLinearAnimZeroDuration",
+ "testPingPongStopAnim",
+ "testPointAnim",
+ "testXPosPointAnim",
+ "testYPosPointAnim",
+ "testEaseInOutAnim",
+ "testIntAnim",
+ "testContinuousAnim",
+ "testWaitAnim",
+ "testParallelAnim",
+ "testParallelAnimRegistry",
+ "testStateAnim",
+ "testNonNodeAttrAnim"
+ )
+ return createAVGTestSuite(availableTests, AnimTestCase, tests)
+
generated by cgit v1.2.3 (git 2.25.1) at 2024-04-30 23:14:09 +0000