subprojects/gst-python/testsuite/test_types.py

   1 # -*- Mode: Python -*-
   2 # vi:si:et:sw=4:sts=4:ts=4
   3 #
   4 # gst-python - Python bindings for GStreamer
   5 # Copyright (C) 2007 Johan Dahlin
   6 #
   7 # This library is free software; you can redistribute it and/or
   8 # modify it under the terms of the GNU Lesser General Public
   9 # License as published by the Free Software Foundation; either
  10 # version 2.1 of the License, or (at your option) any later version.
  11 #
  12 # This library is distributed in the hope that it will be useful,
  13 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15 # Lesser General Public License for more details.
  16 #
  17 # You should have received a copy of the GNU Lesser General Public
  18 # License along with this library; if not, write to the Free Software
  19 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301  USA
  20
  21 import overrides_hack
  22 overrides_hack
  23
  24 from common import TestCase
  25 import unittest, sys
  26
  27 import gi
  28 gi.require_version("Gst", "1.0")
  29 from gi.repository import Gst
  30 Gst.init(None)
  31
  32 Gst.DoubleRange = Gst.DoubleRange
  33
  34 class TestDoubleRange(TestCase):
  35     def testConstructor(self):
  36         Gst.init(None)
  37
  38         Gst.DoubleRange = Gst.DoubleRange(1.2, 3.4)
  39         self.assertEqual(r.start, 1.2)
  40         self.assertEqual(r.stop, 3.4)
  41         self.assertRaises(TypeError, Gst.DoubleRange, {}, 2)
  42         self.assertRaises(TypeError, Gst.DoubleRange, 2, ())
  43         self.assertRaises(TypeError, Gst.DoubleRange, 2, 1)
  44         self.assertRaises(TypeError, Gst.DoubleRange)
  45
  46     def testRepr(self):
  47         Gst.init(None)
  48
  49         self.assertEqual(repr(Gst.DoubleRange(1,2)), '<Gst.DoubleRange [1.0,2.0]>')
  50
  51     def testGetValue(self):
  52         Gst.init(None)
  53
  54         st = Gst.Structure.new_empty("video/x-raw")
  55         st["range"] = Gst.DoubleRange(1,2)
  56         value = st["range"]
  57
  58         self.assertEqual(value.start, 1.0)
  59         self.assertEqual(value.stop, 2.0)
  60
  61
  62 class TestFraction(TestCase):
  63     def testConstructor(self):
  64         Gst.init(None)
  65
  66         frac = Gst.Fraction(1, 2)
  67         self.assertEqual(frac.num, 1)
  68         self.assertEqual(frac.denom, 2)
  69
  70         frac = Gst.Fraction(1)
  71         self.assertEqual(frac.num, 1)
  72         self.assertEqual(frac.denom, 1)
  73
  74         self.assertRaises(TypeError, Gst.Fraction)
  75
  76     def testRepr(self):
  77         Gst.init(None)
  78
  79         self.assertEqual(repr(Gst.Fraction(1, 2)), '<Gst.Fraction 1/2>')
  80
  81     def testEqNe(self):
  82         Gst.init(None)
  83
  84         frac = Gst.Fraction(1, 2)
  85         self.assertEqual(frac, frac)
  86         self.assertEqual(Gst.Fraction(1, 2), Gst.Fraction(1, 2))
  87         self.assertEqual(Gst.Fraction(2, 4), Gst.Fraction(1, 2))
  88
  89         self.assertNotEqual(Gst.Fraction(1, 3), Gst.Fraction(1, 2))
  90         self.assertNotEqual(Gst.Fraction(2, 1), Gst.Fraction(1, 2))
  91
  92     def testMul(self):
  93         Gst.init(None)
  94
  95         self.assertEqual(Gst.Fraction(1, 2) * Gst.Fraction(1, 2), Gst.Fraction(1, 4))
  96         self.assertEqual(Gst.Fraction(2, 3) * Gst.Fraction(4, 5), Gst.Fraction(8, 15))
  97         self.assertEqual(Gst.Fraction(1, 3) * Gst.Fraction(4), Gst.Fraction(4, 3))
  98         self.assertEqual(Gst.Fraction(1, 3) * 4, Gst.Fraction(4, 3))
  99
 100     def testRMul(self):
 101         Gst.init(None)
 102
 103         self.assertEqual(2 * Gst.Fraction(1, 2), Gst.Fraction(1))
 104         self.assertEqual(4 * Gst.Fraction(1, 2), Gst.Fraction(2))
 105         self.assertEqual(-10 * Gst.Fraction(1, 2), Gst.Fraction(-5))
 106
 107     def testDiv(self):
 108         Gst.init(None)
 109
 110         self.assertEqual(Gst.Fraction(1, 3) / Gst.Fraction(1, 4), Gst.Fraction(4, 3))
 111         self.assertEqual(Gst.Fraction(2, 3) / Gst.Fraction(4, 5), Gst.Fraction(10, 12))
 112
 113         self.assertEqual(Gst.Fraction(1, 3) / Gst.Fraction(4), Gst.Fraction(1, 12))
 114         self.assertEqual(Gst.Fraction(1, 3) / 4, Gst.Fraction(1, 12))
 115         self.assertEqual(Gst.Fraction(1, 3) / 2, Gst.Fraction(1, 6))
 116         self.assertEqual(Gst.Fraction(1, 5) / -4, Gst.Fraction(1, -20))
 117
 118     def testRDiv(self):
 119         Gst.init(None)
 120
 121         self.assertEqual(2 / Gst.Fraction(1, 3), Gst.Fraction(6, 1))
 122         self.assertEqual(-4 / Gst.Fraction(1, 5), Gst.Fraction(-20, 1))
 123
 124     def testFloat(self):
 125         Gst.init(None)
 126
 127         self.assertEqual(float(Gst.Fraction(1, 2)), 0.5)
 128
 129     def testPropertyMarshalling(self):
 130         Gst.init(None)
 131
 132         obj = Gst.ElementFactory.make("rawvideoparse")
 133         if not obj:
 134             obj = Gst.ElementFactory.make("rawvideoparse")
 135
 136         if not obj:
 137             # no (raw)videoparse and I don't know of any elements in core or -base using
 138             # fraction properties. Skip this test.
 139             return
 140
 141         value = obj.props.framerate
 142         self.assertEqual(value.num, 25)
 143         self.assertEqual(value.denom, 1)
 144
 145         obj.props.framerate = Gst.Fraction(2, 1)
 146         value = obj.props.framerate
 147         self.assertEqual(value.num, 2)
 148         self.assertEqual(value.denom, 1)
 149
 150         def bad():
 151             obj.props.framerate = 1
 152         self.assertRaises(TypeError, bad)
 153
 154         value = obj.props.framerate
 155         self.assertEqual(value.num, 2)
 156         self.assertEqual(value.denom, 1)
 157
 158     def testGetFractionValue(self):
 159         Gst.init(None)
 160
 161         st = Gst.Structure.from_string("video/x-raw,framerate=10/1")[0]
 162         value = st["framerate"]
 163
 164         self.assertEqual(value.num, 10)
 165         self.assertEqual(value.denom, 1)
 166
 167
 168 class TestFractionRange(TestCase):
 169     def testConstructor(self):
 170         Gst.init(None)
 171
 172         r = Gst.FractionRange(Gst.Fraction(1, 30), Gst.Fraction(1, 2))
 173         self.assertEqual(r.start, Gst.Fraction(1, 30))
 174         self.assertEqual(r.stop, Gst.Fraction(1, 2))
 175         self.assertRaises(TypeError, Gst.FractionRange, Gst.Fraction(1, 2), Gst.Fraction(1, 30))
 176         self.assertRaises(TypeError, Gst.FractionRange, 2, Gst.Fraction(1, 2))
 177         self.assertRaises(TypeError, Gst.FractionRange, Gst.Fraction(1, 2), 2)
 178         self.assertRaises(TypeError, Gst.FractionRange)
 179
 180     def testRepr(self):
 181         Gst.init(None)
 182
 183         self.assertEqual(repr(Gst.FractionRange(Gst.Fraction(1,30), Gst.Fraction(1,2))),
 184                 '<Gst.FractionRange [1/30,1/2]>')
 185
 186     def testGetValue(self):
 187         Gst.init(None)
 188
 189         st = Gst.Structure.new_empty("video/x-raw")
 190         st["range"] = Gst.FractionRange(Gst.Fraction(1, 30), Gst.Fraction(1, 2))
 191         value = st["range"]
 192
 193         self.assertEqual(value.start, Gst.Fraction(1, 30))
 194         self.assertEqual(value.stop, Gst.Fraction(1, 2))
 195
 196 class TestDoubleRange(TestCase):
 197     def testConstructor(self):
 198         Gst.init(None)
 199
 200         r = Gst.DoubleRange(1.2, 3.4)
 201         self.assertEqual(r.start, 1.2)
 202         self.assertEqual(r.stop, 3.4)
 203         self.assertRaises(TypeError, Gst.DoubleRange, {}, 2)
 204         self.assertRaises(TypeError, Gst.DoubleRange, 2, ())
 205         self.assertRaises(TypeError, Gst.DoubleRange, 2, 1)
 206         self.assertRaises(TypeError, Gst.DoubleRange)
 207
 208     def testRepr(self):
 209         Gst.init(None)
 210
 211         self.assertEqual(repr(Gst.DoubleRange(1,2)), '<Gst.DoubleRange [1.0,2.0]>')
 212
 213     def testGetValue(self):
 214         Gst.init(None)
 215
 216         st = Gst.Structure.new_empty("video/x-raw")
 217         st["range"] = Gst.DoubleRange(1,2)
 218         value = st["range"]
 219
 220         self.assertEqual(value.start, 1.0)
 221         self.assertEqual(value.stop, 2.0)
 222
 223
 224 class TestInt64Range(TestCase):
 225     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 226     def testConstructor(self):
 227         Gst.init(None)
 228
 229         r = Gst.Int64Range(range(0, 10, 2))
 230         self.assertEqual(r.range, range(0, 10, 2))
 231         self.assertRaises(TypeError, Gst.Int64Range, range(1, 10, 2))
 232         self.assertRaises(TypeError, Gst.Int64Range, range(0, 9, 2))
 233         self.assertRaises(TypeError, Gst.Int64Range, range(10, 0))
 234         self.assertRaises(TypeError, Gst.Int64Range, 1)
 235         self.assertRaises(TypeError, Gst.Int64Range)
 236
 237     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 238     def testRepr(self):
 239         Gst.init(None)
 240
 241         self.assertEqual(repr(Gst.Int64Range(range(0, 10, 2))), '<Gst.Int64Range [0,10,2]>')
 242
 243     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 244     def testGetValue(self):
 245         Gst.init(None)
 246
 247         st = Gst.Structure.new_empty("video/x-raw")
 248         st["range"] = Gst.Int64Range(range(0, 10, 2))
 249         value = st["range"]
 250
 251         self.assertEqual(value, range(0, 10, 2))
 252
 253
 254 class TestValueArray(TestCase):
 255     def testConstructor(self):
 256         Gst.init(None)
 257
 258         a = Gst.ValueArray((1,2,3))
 259         self.assertEqual(a.array, [1,2,3])
 260
 261         self.assertRaises(TypeError, Gst.ValueArray, 1)
 262         self.assertRaises(TypeError, Gst.ValueArray)
 263
 264     def testRepr(self):
 265         Gst.init(None)
 266
 267         self.assertEqual(repr(Gst.ValueArray([1,2,3])), '<Gst.ValueArray <1,2,3>>')
 268
 269     def testPropertyMarshalling(self):
 270         Gst.init(None)
 271
 272         obj = Gst.ElementFactory.make("rawvideoparse")
 273
 274         if not obj:
 275             # no rawvideoparse and I don't know of any elements in core or -base using
 276             # fraction properties. Skip this test.
 277             return
 278
 279         value = obj.props.plane_strides
 280         self.assertEqual(value[0], 320)
 281         self.assertEqual(value[1], 160)
 282         self.assertEqual(value[2], 160)
 283
 284         obj.props.plane_strides = Gst.ValueArray([640,320,320])
 285
 286         value = obj.props.plane_strides
 287         self.assertEqual(value[0], 640)
 288         self.assertEqual(value[1], 320)
 289         self.assertEqual(value[2], 320)
 290
 291         def bad():
 292             obj.props.plane_strides = 1
 293         self.assertRaises(TypeError, bad)
 294
 295         value = obj.props.plane_strides
 296         self.assertEqual(value[0], 640)
 297         self.assertEqual(value[1], 320)
 298         self.assertEqual(value[2], 320)
 299
 300     def testGetValue(self):
 301         Gst.init(None)
 302
 303         st = Gst.Structure.new_empty("video/x-raw")
 304         st["array"] = Gst.ValueArray([Gst.Fraction(1, 30), Gst.Fraction(1, 2)])
 305         value = st["array"]
 306         st["array"] = Gst.ValueArray(value)
 307
 308         self.assertEqual(value[0], Gst.Fraction(1, 30))
 309         self.assertEqual(value[1], Gst.Fraction(1, 2))
 310
 311         st["matrix"] = Gst.ValueArray([Gst.ValueArray([0, 1]), Gst.ValueArray([-1, 0])])
 312         value = st["matrix"]
 313
 314         self.assertEqual(value[0][0], 0)
 315         self.assertEqual(value[0][1], 1)
 316         self.assertEqual(value[1][0], -1)
 317         self.assertEqual(value[1][1], 0)
 318
 319
 320 class TestValueList(TestCase):
 321     def testConstructor(self):
 322         Gst.init(None)
 323
 324         a = Gst.ValueList((1,2,3))
 325         self.assertEqual(a.array, [1,2,3])
 326
 327         self.assertRaises(TypeError, Gst.ValueList, 1)
 328         self.assertRaises(TypeError, Gst.ValueList)
 329
 330     def testRepr(self):
 331         Gst.init(None)
 332
 333         self.assertEqual(repr(Gst.ValueList([1,2,3])), '<Gst.ValueList {1,2,3}>')
 334
 335     def testGetValue(self):
 336         Gst.init(None)
 337
 338         st = Gst.Structure.new_empty("video/x-raw")
 339         st["framerate"] = Gst.ValueList([Gst.Fraction(1, 30), Gst.Fraction(1, 2)])
 340         value = st["framerate"]
 341
 342         self.assertEqual(value[0], Gst.Fraction(1, 30))
 343         self.assertEqual(value[1], Gst.Fraction(1, 2))
 344
 345         st["matrix"] = Gst.ValueList([Gst.ValueList([0, 1]), Gst.ValueList([-1 ,0])])
 346         value = st["matrix"]
 347
 348         self.assertEqual(value[0][0], 0)
 349         self.assertEqual(value[0][1], 1)
 350         self.assertEqual(value[1][0], -1)
 351         self.assertEqual(value[1][1], 0)
 352
 353 class TestIntRange(TestCase):
 354     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 355     def testConstructor(self):
 356         Gst.init(None)
 357
 358         r = Gst.IntRange(range(0, 10, 2))
 359         self.assertEqual(r.range, range(0, 10, 2))
 360         self.assertRaises(TypeError, Gst.IntRange, range(1, 10, 2))
 361         self.assertRaises(TypeError, Gst.IntRange, range(0, 9, 2))
 362         self.assertRaises(TypeError, Gst.IntRange, range(10, 0))
 363         self.assertRaises(TypeError, Gst.IntRange, 1)
 364         self.assertRaises(TypeError, Gst.IntRange)
 365
 366     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 367     def testRepr(self):
 368         Gst.init(None)
 369
 370         self.assertEqual(repr(Gst.IntRange(range(0, 10, 2))), '<Gst.IntRange [0,10,2]>')
 371
 372     @unittest.skipUnless(sys.version_info >= (3, 0), "requires Python 3")
 373     def testGetValue(self):
 374         Gst.init(None)
 375
 376         st = Gst.Structure.new_empty("video/x-raw")
 377         st["range"] = Gst.IntRange(range(0, 10, 2))
 378         value = st["range"]
 379
 380         self.assertEqual(value, range(0, 10, 2))
 381
 382
 383 class TestBitmask(TestCase):
 384     def testConstructor(self):
 385         Gst.init(None)
 386
 387         r = Gst.Bitmask(1 << 5)
 388         self.assertEqual(r, 1 << 5)
 389
 390     def testGetValue(self):
 391         Gst.init(None)
 392
 393         self.assertEqual(Gst.Structure('test,test=(bitmask)0x20')['test'], 1 << 5)
 394
 395     def testStr(self):
 396         Gst.init(None)
 397
 398         r = Gst.Bitmask(1 << 5)
 399         if sys.version_info >= (3, 0):
 400             self.assertEqual(str(r), '0x20')
 401         else:
 402             self.assertEqual(str(r), '0x20L')