falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6800 Commits
16 Branches
16GB
Tree: e6d25394ab
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e6d25394ab'
${ noResults }
Carla/source/modules/lilv/lilv-0.24.0/bindings/test/python/test_api.py

291 lines
14KB
Raw Blame History 

  1. # Copyright 2016 David Robillard <d@drobilla.net>

  2. # Copyright 2013 Kaspar Emanuel <kaspar.emanuel@gmail.com>

  3. #

  4. # Permission to use, copy, modify, and/or distribute this software for any

  5. # purpose with or without fee is hereby granted, provided that the above

  6. # copyright notice and this permission notice appear in all copies.

  7. #

  8. # THIS SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

  9. # WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

  10. # MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

  11. # ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

  12. # WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

  13. # ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

  14. # OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  15. 

  16. import lilv

  17. import unittest

  18. import os

  19. 

  20. location = "file://" + os.getcwd() + "/bindings/bindings_test_plugin.lv2/"

  21. 

  22. class NodeTests(unittest.TestCase):

  23.     def setUp(self):

  24.         self.world = lilv.World()

  25.     def testNodes(self):

  26.         aint    = self.world.new_int(1)

  27.         aint2   = self.world.new_int(1)

  28.         aint3   = self.world.new_int(3)

  29.         afloat  = self.world.new_float(2.0)

  30.         atrue   = self.world.new_bool(True)

  31.         afalse  = self.world.new_bool(False)

  32.         auri    = self.world.new_uri("http://example.org")

  33.         afile   = self.world.new_file_uri(None, "/foo/bar")

  34.         astring = self.world.new_string("hello")

  35.         self.assertEqual(auri.get_turtle_token(), '<http://example.org>')

  36.         self.assertTrue(aint.is_int())

  37.         self.assertTrue(afloat.is_float())

  38.         self.assertTrue(auri.is_uri())

  39.         self.assertTrue(astring.is_string())

  40.         self.assertTrue(astring.is_literal())

  41.         self.assertFalse(auri.is_blank())

  42.         self.assertTrue(int(aint) == 1)

  43.         self.assertTrue(float(afloat) == 2.0)

  44.         self.assertTrue(bool(atrue))

  45.         self.assertFalse(bool(afalse))

  46.         self.assertEqual(afile.get_path(), "/foo/bar")

  47.         self.assertTrue(aint == aint2)

  48.         self.assertTrue(aint != aint3)

  49.         self.assertTrue(aint != afloat)

  50.         with self.assertRaises(ValueError):

  51.             int(atrue)

  52.         with self.assertRaises(ValueError):

  53.             float(aint)

  54.         with self.assertRaises(ValueError):

  55.             bool(astring)

  56. 

  57. class UriTests(unittest.TestCase):

  58.     def setUp(self):

  59.         self.world = lilv.World()

  60.         self.world.load_all();

  61.     def testInvalidURI(self):

  62.         self.plugin_uri = self.world.new_uri("invalid_uri")

  63.         self.assertIsNone(self.plugin_uri)

  64.     def testNonExistentURI(self):

  65.         self.plugin_uri = self.world.new_uri("exist:does_not")

  66.         self.plugin = self.world.get_all_plugins().get_by_uri(self.plugin_uri)

  67.         self.assertEqual(self.plugin, None)

  68.     def testPortTypes(self):

  69.         self.assertIsNotNone(self.world.new_uri(lilv.LILV_URI_INPUT_PORT))

  70.     def testPortTypes2(self):

  71.         self.assertIsNotNone(self.world.new_uri(lilv.LILV_URI_OUTPUT_PORT))

  72.     def testPortTypes3(self):

  73.         self.assertIsNotNone(self.world.new_uri(lilv.LILV_URI_AUDIO_PORT))

  74.     def testPortTypes4(self):

  75.         self.assertIsNotNone(self.world.new_uri(lilv.LILV_URI_CONTROL_PORT))

  76. 

  77. class PluginClassTests(unittest.TestCase):

  78.     def setUp(self):

  79.         self.world = lilv.World()

  80.     def testPluginClasses(self):

  81.         pclass = self.world.get_plugin_class()

  82.         self.assertIsNotNone(pclass)

  83.         self.assertIsNone(pclass.get_parent_uri())

  84.         self.assertIsNotNone(pclass.get_uri())

  85.         self.assertIsNotNone(pclass.get_label())

  86.         self.assertEqual(str(pclass.get_uri()), str(pclass))

  87.         for i in pclass.get_children():

  88.             self.assertIsNotNone(i)

  89.             self.assertIsNotNone(i.get_uri())

  90.             self.assertIsNotNone(i.get_label())

  91. 

  92. class PluginClassesTests(unittest.TestCase):

  93.     def setUp(self):

  94.         self.world = lilv.World()

  95.         self.world.load_all()

  96.     def testPluginClasses(self):

  97.         classes = self.world.get_plugin_classes()

  98.         pclass = self.world.get_plugin_class()

  99.         self.assertIsNotNone(classes)

  100.         self.assertIsNotNone(pclass)

  101.         self.assertTrue(pclass in classes)

  102.         self.assertTrue(pclass.get_uri() in classes)

  103.         self.assertGreater(len(classes), 1)

  104.         self.assertIsNotNone(classes[0])

  105.         self.assertIsNotNone(classes[pclass.get_uri()])

  106. 

  107. class LoadTests(unittest.TestCase):

  108.     def setUp(self):

  109.         self.world = lilv.World()

  110.         self.bundle_uri = self.world.new_uri(location)

  111.         self.world.load_specifications()

  112.         self.world.load_plugin_classes()

  113.     def tearDown(self):

  114.         del self.world

  115.     def testLoadUnload(self):

  116.         self.world.load_bundle(self.bundle_uri)

  117.         plugins = self.world.get_all_plugins()

  118.         plugin  = plugins.get(plugins.begin())

  119.         self.world.load_resource(plugin)

  120.         self.world.unload_resource(plugin)

  121.         self.world.unload_bundle(self.bundle_uri)

  122. 

  123. class PluginTests(unittest.TestCase):

  124.     def setUp(self):

  125.         self.world = lilv.World()

  126.         self.world.set_option(lilv.OPTION_FILTER_LANG, self.world.new_bool(True))

  127.         self.bundle_uri = self.world.new_uri(location)

  128.         self.assertIsNotNone(self.bundle_uri, "Invalid URI: '" + location + "'")

  129.         self.world.load_bundle(self.bundle_uri)

  130.         self.plugins = self.world.get_all_plugins()

  131.         self.plugin  = self.plugins.get(self.plugins.begin())

  132.         self.assertTrue(self.plugin.verify())

  133.         self.assertTrue(self.plugin in self.plugins)

  134.         self.assertTrue(self.plugin.get_uri() in self.plugins)

  135.         self.assertEqual(self.plugins[self.plugin.get_uri()], self.plugin)

  136.         self.assertIsNotNone(self.plugin, msg="Test plugin not found at location: '" + location + "'")

  137.         self.assertEqual(location, str(self.plugin.get_bundle_uri()))

  138.         self.plugin_uri = self.plugin.get_uri()

  139.         self.assertEqual(self.plugin.get_uri(), self.plugin_uri, "URI equality broken")

  140.         self.instance = lilv.Instance(self.plugin, 48000, None)

  141.         self.assertIsNotNone(self.instance)

  142.         self.lv2_InputPort    = self.world.new_uri(lilv.LILV_URI_INPUT_PORT)

  143.         self.lv2_OutputPort   = self.world.new_uri(lilv.LILV_URI_OUTPUT_PORT)

  144.         self.lv2_AudioPort    = self.world.new_uri(lilv.LILV_URI_AUDIO_PORT)

  145.         self.lv2_ControlPort  = self.world.new_uri(lilv.LILV_URI_CONTROL_PORT)

  146.     def testGetters(self):

  147.         self.assertIsNotNone(self.plugin.get_bundle_uri())

  148.         self.assertGreater(len(self.plugin.get_data_uris()), 0)

  149.         self.assertIsNotNone(self.plugin.get_library_uri())

  150.         self.assertTrue(self.plugin.get_name().is_string())

  151.         self.assertTrue(self.plugin.get_class().get_uri().is_uri())

  152.         self.assertEqual(len(self.plugin.get_value(self.world.ns.doap.license)), 1)

  153.         licenses = self.plugin.get_value(self.world.ns.doap.license)

  154.         features = self.plugin.get_value(self.world.ns.lv2.optionalFeature)

  155.         self.assertEqual(len(licenses), 1)

  156.         self.assertTrue(licenses[0] in licenses)

  157.         with self.assertRaises(IndexError):

  158.             self.assertIsNone(licenses[len(licenses)])

  159.         self.assertEqual(len(licenses) + len(features),

  160.                          len(licenses.merge(features)))

  161.         self.assertEqual(licenses.get(licenses.begin()), self.world.new_uri('http://opensource.org/licenses/isc'))

  162.         self.assertEqual(licenses[0], licenses.get(licenses.begin()))

  163.         self.assertTrue(self.plugin.has_feature(self.world.ns.lv2.hardRTCapable))

  164.         self.assertEqual(len(self.plugin.get_supported_features()), 1)

  165.         self.assertEqual(len(self.plugin.get_optional_features()), 1)

  166.         self.assertEqual(len(self.plugin.get_required_features()), 0)

  167.         self.assertFalse(self.plugin.has_extension_data(self.world.new_uri('http://example.org/nope')))

  168.         self.assertEqual(len(self.plugin.get_extension_data()), 0)

  169.         self.assertEqual(len(self.plugin.get_extension_data()), 0)

  170.         self.assertFalse(self.plugin.has_latency())

  171.         self.assertIsNone(self.plugin.get_latency_port_index())

  172.     def testPorts(self):

  173.         self.assertEqual(self.plugin.get_num_ports(), 4)

  174.         self.assertIsNotNone(self.plugin.get_port(0))

  175.         self.assertIsNotNone(self.plugin.get_port(1))

  176.         self.assertIsNotNone(self.plugin.get_port(2))

  177.         self.assertIsNotNone(self.plugin.get_port(3))

  178.         self.assertIsNone(self.plugin.get_port_by_index(4))

  179.         self.assertIsNotNone(self.plugin.get_port("input"))

  180.         self.assertIsNotNone(self.plugin.get_port("output"))

  181.         self.assertIsNotNone(self.plugin.get_port("audio_input"))

  182.         self.assertIsNotNone(self.plugin.get_port("audio_output"))

  183.         self.assertIsNone(self.plugin.get_port_by_symbol("nonexistent"))

  184.         self.assertIsNone(self.plugin.get_port_by_designation(self.world.ns.lv2.InputPort, self.world.ns.lv2.control))

  185.         self.assertIsNone(self.plugin.get_project())

  186.         self.assertIsNone(self.plugin.get_author_name())

  187.         self.assertIsNone(self.plugin.get_author_email())

  188.         self.assertIsNone(self.plugin.get_author_homepage())

  189.         self.assertFalse(self.plugin.is_replaced())

  190.         self.assertEqual(0, len(self.plugin.get_related(self.world.new_uri("http://example.org/Type"))))

  191.         self.assertEqual(1, self.plugin.get_num_ports_of_class(self.lv2_InputPort, self.lv2_AudioPort))

  192.         port = self.plugin.get_port("input")

  193.         self.assertTrue(port.get_node().is_blank())

  194.         self.assertEqual(0, port.get(self.world.ns.lv2.index))

  195.         self.assertEqual(1, len(port.get_value(self.world.ns.lv2.symbol)))

  196.         self.assertEqual(port.get_value(self.world.ns.lv2.symbol)[0], "input")

  197.         self.assertFalse(port.has_property(self.world.ns.lv2.latency))

  198.         self.assertFalse(port.supports_event(self.world.ns.midi.MidiEvent))

  199.         self.assertEqual(0, port.get_index())

  200.         self.assertEqual("input", port.get_symbol())

  201.         self.assertEqual("Input", port.get_name())

  202.         self.assertEqual([self.world.ns.lv2.ControlPort, self.world.ns.lv2.InputPort],

  203.                          list(port.get_classes()))

  204.         self.assertTrue(port.is_a(self.world.ns.lv2.ControlPort))

  205.         self.assertFalse(port.is_a(self.world.ns.lv2.AudioPort))

  206.         self.assertEquals((0.5, 0.0, 1.0), port.get_range())

  207.         self.assertEquals(0, len(port.get_properties()))

  208.     def testScalePoints(self):

  209.         port = self.plugin.get_port("input")

  210.         points = port.get_scale_points()

  211.         self.assertEqual(points[0].get_label(), "off")

  212.         self.assertEqual(points[0].get_value(), 0.0)

  213.         self.assertEqual(points[1].get_label(), "on")

  214.         self.assertEqual(points[1].get_value(), 1.0)

  215.     def testPortCount(self):

  216.         self.assertEqual(1, self.plugin.get_num_ports_of_class(self.lv2_OutputPort, self.lv2_AudioPort))

  217.         self.assertEqual(1, self.plugin.get_num_ports_of_class(self.lv2_OutputPort, self.lv2_ControlPort))

  218.         self.assertEqual(1, self.plugin.get_num_ports_of_class(self.lv2_InputPort, self.lv2_AudioPort))

  219.         self.assertEqual(1, self.plugin.get_num_ports_of_class(self.lv2_InputPort, self.lv2_ControlPort))

  220. 

  221. class QueryTests(unittest.TestCase):

  222.     def setUp(self):

  223.         self.world = lilv.World()

  224.         self.world.load_all()

  225.         self.bundle_uri = self.world.new_uri(location)

  226.         self.world.load_bundle(self.bundle_uri)

  227.         self.plugins = self.world.get_all_plugins()

  228.         self.plugin  = self.plugins.get(self.plugins.begin())

  229.     def testNamespaces(self):

  230.         self.assertEqual(self.world.ns.lv2, "http://lv2plug.in/ns/lv2core#")

  231.         self.assertEqual(self.world.ns.lv2.Plugin, "http://lv2plug.in/ns/lv2core#Plugin")

  232.     def testQuery(self):

  233.         self.assertTrue(self.world.ask(None,

  234.                                        self.world.ns.rdf.type,

  235.                                        self.world.ns.lv2.Plugin))

  236.         self.assertLess(0, len(self.world.find_nodes(None,

  237.                                                      self.world.ns.rdf.type,

  238.                                                      self.world.ns.lv2.Plugin)))

  239.         self.assertEqual(self.plugin.get_uri(), self.world.get(None,

  240.                                                                self.world.ns.rdf.type,

  241.                                                                self.world.ns.lv2.Plugin))

  242. 

  243. class InstanceTests(unittest.TestCase):

  244.     def setUp(self):

  245.         self.world = lilv.World()

  246.         self.bundle_uri = self.world.new_uri(location)

  247.         self.world.load_bundle(self.bundle_uri)

  248.         self.plugins = self.world.get_all_plugins()

  249.         self.plugin = self.plugins[0]

  250.         self.instance = lilv.Instance(self.plugin, 48000)

  251.         self.assertEqual(self.plugin.get_uri(), self.instance.get_uri())

  252.         self.assertIsNone(self.instance.get_extension_data(self.world.new_uri("http://example.org/ext")))

  253.         self.assertIsNone(self.instance.get_extension_data("http://example.org/ext"))

  254.     def testRun(self):

  255.         import numpy

  256.         n_samples = 100

  257.         buf = numpy.zeros(n_samples)

  258.         with self.assertRaises(Exception):

  259.             self.instance.connect_port(0, "hello")

  260.         self.instance.connect_port(0, None)

  261.         self.instance.connect_port(0, None)

  262.         self.instance.connect_port(2, buf)

  263.         self.instance.connect_port(3, buf)

  264.         self.instance.activate()

  265.         self.instance.run(n_samples)

  266.         self.instance.deactivate()

  267. 

  268. class UITests(unittest.TestCase):

  269.     def setUp(self):

  270.         self.world = lilv.World()

  271.         self.bundle_uri = self.world.new_uri(location)

  272.         self.world.load_bundle(self.bundle_uri)

  273.         self.plugins = self.world.get_all_plugins()

  274.         self.plugin = self.plugins[0]

  275.     def testUI(self):

  276.         uis = self.plugin.get_uis()

  277.         ui_uri = self.world.new_uri('http://example.org/lilv-bindings-test-plugin-ui')

  278.         self.assertEqual(1, len(uis))

  279.         self.assertEqual(str(uis[0]), str(ui_uri))

  280.         self.assertEqual(uis[0], str(ui_uri))

  281.         self.assertEqual(uis[0].get_uri(), ui_uri)

  282.         self.assertEqual(uis[0].get_bundle_uri(), self.bundle_uri)

  283.         self.assertEqual(uis[0].get_binary_uri(), str(self.bundle_uri) + "TODO")

  284.         self.assertEqual(uis[uis[0].get_uri()], uis[0])

  285.         self.assertTrue(uis[0].is_a(self.world.ns.ui.GtkUI))

  286.         self.assertTrue(uis[0] in uis)

  287.         self.assertTrue(uis[0].get_uri() in uis)

  288.         self.assertEqual([self.world.ns.ui.GtkUI], list(uis[0].get_classes()))

  289.         for ui in uis:

  290.             print(ui)