test.py

   1 import os
   2 import sys
   3 import struct
   4 import time
   5 import unittest
   6
   7 # This is for locale testing
   8 from gi.repository import GObject, Gdk, Gtk
   9
  10 from calfbox import cbox
  11 cbox.init_engine("")
  12 cbox.start_noaudio(44100)
  13
  14 cbox.Config.add_section("drumpattern:pat1", """
  15 title=Straight - Verse
  16 beats=4
  17 track1=bd
  18 track2=sd
  19 track3=hh
  20 track4=ho
  21 bd_note=c1
  22 sd_note=d1
  23 hh_note=f#1
  24 ho_note=a#1
  25 bd_trigger=9... .... 9.6. ....
  26 sd_trigger=.... 9..5 .2.. 9...
  27 hh_trigger=9353 7353 7353 73.3
  28 ho_trigger=.... .... .... ..3.
  29 """)
  30 cbox.Config.add_section("fxpreset:piano_reverb", """
  31 engine=reverb
  32 """)
  33 cbox.Config.add_section("instrument:vintage", """
  34 engine=sampler
  35 """)
  36
  37 global Document
  38 Document = cbox.Document
  39
  40 Document.dump()
  41
  42 class TestCbox(unittest.TestCase):
  43     def verify_uuid(self, uuid, class_name, path = None):
  44         self.assertEqual(cbox.GetThings(Document.uuid_cmd(uuid, "/get_class_name"), ['class_name'], []).class_name, class_name)
  45         if path is not None:
  46             self.assertEqual(cbox.GetThings(path + "/status", ['uuid'], []).uuid, uuid)
  47         self.assertEqual(cbox.GetThings(Document.uuid_cmd(uuid, "/status"), ['uuid'], []).uuid, uuid)
  48
  49     def test_scene(self):
  50         scene = Document.get_scene()
  51         self.assertEqual(Document.get_engine().status().scenes[0], scene)
  52
  53         scene.clear()
  54         scene.add_new_instrument_layer("test_instr", "sampler")
  55
  56         scene_status = scene.status()
  57         layer = scene_status.layers[0]
  58         self.verify_uuid(scene.uuid, "cbox_scene", "/scene")
  59         self.verify_uuid(layer.uuid, "cbox_layer", "/scene/layer/1")
  60
  61         layers = scene.status().layers
  62         self.assertEqual(len(layers), 1)
  63         self.assertEqual(layers[0].uuid, layer.uuid)
  64         layers[0].set_consume(0)
  65         self.assertEqual(layers[0].status().consume, 0)
  66         layers[0].set_consume(1)
  67         self.assertEqual(layers[0].status().consume, 1)
  68         layers[0].set_enable(0)
  69         self.assertEqual(layers[0].status().enable, 0)
  70         layers[0].set_enable(1)
  71         self.assertEqual(layers[0].status().enable, 1)
  72
  73         layer_status = layers[0].status()
  74         instr_uuid = layer_status.instrument.uuid
  75         iname = layer_status.instrument_name
  76         self.assertEqual(iname, 'test_instr')
  77         self.verify_uuid(instr_uuid, "cbox_instrument", "/scene/instr/%s" % iname)
  78
  79         aux = scene.load_aux("piano_reverb")
  80         module = aux.slot.engine
  81         self.verify_uuid(aux.uuid, "cbox_aux_bus", "/scene/aux/piano_reverb")
  82         scene.delete_aux("piano_reverb")
  83
  84     def test_aux_scene(self):
  85         engine = Document.new_engine(44100, 1024)
  86         scene = engine.new_scene()
  87         self.assertEqual(engine.status().scenes[0], scene)
  88         scene.add_instrument_layer("vintage")
  89         scene_status = scene.status()
  90         layer = scene_status.layers[0]
  91         self.verify_uuid(scene.uuid, "cbox_scene")
  92         self.verify_uuid(layer.uuid, "cbox_layer", scene.make_path("/layer/1"))
  93
  94         layers = scene.status().layers
  95         self.assertEqual(len(layers), 1)
  96         self.assertEqual(layers[0].uuid, layer.uuid)
  97         layers[0].set_consume(0)
  98         self.assertEqual(layers[0].status().consume, 0)
  99         layers[0].set_consume(1)
 100         self.assertEqual(layers[0].status().consume, 1)
 101         layers[0].set_enable(0)
 102         self.assertEqual(layers[0].status().enable, 0)
 103         layers[0].set_enable(1)
 104         self.assertEqual(layers[0].status().enable, 1)
 105
 106         layer_status = layers[0].status()
 107         instr_uuid = layer_status.instrument.uuid
 108         iname = layer_status.instrument_name
 109         self.verify_uuid(instr_uuid, "cbox_instrument", scene.make_path("/instr/%s" % iname))
 110
 111         aux = scene.load_aux("piano_reverb")
 112         module = aux.slot.engine
 113         self.verify_uuid(aux.uuid, "cbox_aux_bus", scene.make_path("/aux/piano_reverb"))
 114         scene.delete_aux("piano_reverb")
 115
 116     def test_sampler_api(self):
 117         engine = Document.new_engine(44100, 1024)
 118         scene = engine.new_scene()
 119         scene.add_new_instrument_layer("temporary", "sampler")
 120         scene_status = scene.status()
 121         layer = scene_status.layers[0]
 122         self.verify_uuid(scene.uuid, "cbox_scene")
 123         self.verify_uuid(layer.uuid, "cbox_layer", scene.make_path("/layer/1"))
 124         instrument = layer.get_instrument()
 125         self.assertEqual(instrument.status().engine, "sampler")
 126
 127         program0 = instrument.engine.load_patch_from_file(0, 'synthbass.sfz', 'test_sampler_sfz_loader')
 128         self.assertNotEqual(program0, None)
 129         self.assertEqual(program0.status().in_use, 16)
 130         program1 = instrument.engine.load_patch_from_string(0, '.', '<group> resonance=3 <region> unknown=123 key=36 sample=impulse.wav cutoff=1000 <region> key=37 cutoff=2000 sample=impulse.wav ', 'test_sfz_parser_trailing_spaces')
 131         self.assertNotEqual(program1, None)
 132         self.assertEqual(program1.status().in_use, 16)
 133         self.assertEqual(program1.status().name, 'test_sfz_parser_trailing_spaces')
 134         self.assertRegex(program1.get_regions()[0].as_string(), 'sample=.*impulse\.wav')
 135         program2 = instrument.engine.load_patch_from_string(0, '.', '<group> resonance=3 <region> unknown=123 key=36 sample=impulse.wav cutoff=1000.5 <region> key=37 sample=impulse.wav cutoff=2000', 'test_sampler_api')
 136         self.assertNotEqual(program2, None)
 137         self.assertEqual(program2.status().in_use, 16)
 138         try:
 139             program1.status()
 140             self.assertTrue(False)
 141         except Exception as e:
 142             self.assertTrue('UUID not found' in str(e))
 143         patches = instrument.engine.get_patches()
 144         patches_dict = {}
 145         self.assertEqual(len(patches), 1)
 146         for (patchid, patchdata) in patches.items():
 147             patchname, program, patchchannelcount = patchdata
 148             self.verify_uuid(program.uuid, 'sampler_program')
 149             self.assertEqual(program.status().program_no, patchid)
 150             self.assertEqual(program.status().name, 'test_sampler_api')
 151             self.assertEqual(program.status().sample_dir, '.')
 152             self.assertEqual(program.status().program_no, 0)
 153             self.assertEqual(program.status().in_use, 16)
 154             instrument.engine.set_patch(1, 0)
 155             self.assertEqual(program.status().in_use, 16)
 156             instrument.engine.set_patch(2, 0)
 157             self.assertEqual(program.status().in_use, 16)
 158             regions = program.get_regions()
 159             patches_dict[patchid] = (patchname, len(regions))
 160             for region in regions:
 161                 region_str = Document.map_uuid(region.uuid).as_string()
 162                 print (patchname, region.uuid, region_str)
 163                 if patchname == 'test_sampler_api':
 164                     self.assertTrue('impulse.wav' in region_str)
 165                     self.assertTrue('key=c' in region_str)
 166                     if 'key=c2' in region_str:
 167                         self.assertTrue('unknown=123' in region_str)
 168                         self.assertTrue('cutoff=1000.5' in region_str)
 169                     else:
 170                         self.assertFalse('unknown=123' in region_str)
 171                         self.assertTrue('cutoff=2000' in region_str)
 172             program.add_control_init(11, 64)
 173             self.assertTrue((11,64) in program.get_control_inits())
 174             program.delete_control_init(11, 0)
 175             program.add_control_init(11, 0)
 176             program.add_control_init(11, 64)
 177             self.assertTrue((11,0) in program.get_control_inits())
 178             self.assertTrue((11,64) in program.get_control_inits())
 179             program.delete_control_init(11, 0)
 180             self.assertTrue((11,0) not in program.get_control_inits())
 181             self.assertTrue((11,64) in program.get_control_inits())
 182             program.delete_control_init(11, 0)
 183             self.assertTrue((11,0) not in program.get_control_inits())
 184             self.assertTrue((11,64) not in program.get_control_inits())
 185             program.add_control_init(11, 0)
 186             program.add_control_init(11, 64)
 187             program.delete_control_init(11, -1)
 188             self.assertTrue((11,0) not in program.get_control_inits())
 189             self.assertTrue((11,64) not in program.get_control_inits())
 190         self.assertEqual(patches_dict, {0 : ('test_sampler_api', 2)})
 191         group = region.status().parent_group
 192         self.assertTrue("resonance=3" in group.as_string())
 193         region.set_param("cutoff", 9000)
 194         self.assertTrue('cutoff=9000' in region.as_string())
 195         region.set_param("sample", 'test.wav')
 196         self.assertTrue('test.wav' in region.as_string())
 197         region.set_param("key", '12')
 198         self.assertTrue('key=c0' in region.as_string())
 199         print (region.status())
 200         print (group.as_string())
 201         print (region.as_string())
 202
 203     def test_rt(self):
 204         rt = Document.get_rt()
 205         self.assertEqual(cbox.GetThings(Document.uuid_cmd(rt.uuid, "/status"), ['uuid'], []).uuid, rt.uuid)
 206
 207     def test_recorder_api(self):
 208         engine = Document.new_engine(44100, 512)
 209         scene = engine.new_scene()
 210         scene.add_new_instrument_layer("temporary", "sampler")
 211         layer = scene.status().layers[0]
 212         instr = layer.status().instrument
 213         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [])
 214
 215         meter_uuid = cbox.GetThings("/new_meter", ['uuid'], []).uuid
 216         instr.cmd('/output/1/rec_dry/attach', None, meter_uuid)
 217         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [meter_uuid])
 218         instr.cmd('/output/1/rec_dry/detach', None, meter_uuid)
 219         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [])
 220         if os.path.exists("test.wav"):
 221             os.unlink('test.wav')
 222
 223         rec = engine.new_recorder('test.wav')
 224         self.assertEqual(rec.status().filename, 'test.wav')
 225         rec_uuid = rec.uuid
 226         instr.cmd('/output/1/rec_dry/attach', None, rec_uuid)
 227         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [rec_uuid])
 228         instr.cmd('/output/1/rec_dry/detach', None, rec_uuid)
 229         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [])
 230         self.assertTrue(os.path.exists('test.wav'))
 231         self.assertTrue(os.path.getsize('test.wav') < 512)
 232         os.unlink('test.wav')
 233
 234         rec = engine.new_recorder('test.wav')
 235         self.assertEqual(rec.status().filename, 'test.wav')
 236         rec_uuid = rec.uuid
 237         instr.cmd('/output/1/rec_dry/attach', None, rec_uuid)
 238         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [rec_uuid])
 239         data = struct.unpack_from("512f", engine.render_stereo(512))
 240         instr.cmd('/output/1/rec_dry/detach', None, rec_uuid)
 241         self.assertEqual(instr.get_things("/output/1/rec_dry/status", ['*handler']).handler, [])
 242         rec.delete()
 243         self.assertTrue(os.path.exists('test.wav'))
 244         self.assertTrue(os.path.getsize('test.wav') > 512 * 4 * 2)
 245
 246     def test_song(self):
 247         song = Document.get_song()
 248         song.clear()
 249         tp = song.status()
 250         self.assertEqual(tp.tracks, [])
 251         self.assertEqual(tp.patterns, [])
 252         self.assertEqual(tp.mtis, [])
 253
 254         track = song.add_track()
 255         pattern = song.load_drum_pattern('pat1')
 256         track.add_clip(0, 0, 192, pattern)
 257
 258         song = Document.get_song()
 259         tp = song.status()
 260         self.assertEqual(tp.tracks[0].name, 'Unnamed')
 261         self.assertEqual(tp.patterns[0].name, 'pat1')
 262         track = tp.tracks[0].track
 263         pattern = tp.patterns[0].pattern
 264
 265         track.set_name("Now named")
 266         self.assertEqual(track.status().name, 'Now named')
 267         pattern.set_name("pat1alt")
 268         self.assertEqual(pattern.status().name, 'pat1alt')
 269
 270         tp = song.status()
 271         self.assertEqual(tp.tracks[0].name, 'Now named')
 272         self.assertEqual(tp.patterns[0].name, 'pat1alt')
 273
 274         clips = track.status().clips
 275         self.assertEqual(clips[0].pos, 0)
 276         self.assertEqual(clips[0].offset, 0)
 277         self.assertEqual(clips[0].length, 192)
 278         self.assertEqual(clips[0].pattern, pattern)
 279         clip1 = clips[0].clip
 280
 281         clip2 = track.add_clip(192, 96, 48, pattern)
 282
 283         clip2_data = clip2.status()
 284         self.assertEqual(clip2_data.pos, 192)
 285         self.assertEqual(clip2_data.offset, 96)
 286         self.assertEqual(clip2_data.length, 48)
 287         self.assertEqual(clip2_data.pattern, pattern)
 288
 289         clips = track.status().clips
 290         self.assertEqual(clips, [cbox.ClipItem(0, 0, 192, pattern.uuid, clip1.uuid), cbox.ClipItem(192, 96, 48, pattern.uuid, clip2.uuid)])
 291
 292         clip1.delete()
 293
 294         clips = track.status().clips
 295         self.assertEqual(clips, [cbox.ClipItem(192, 96, 48, pattern.uuid, clip2.uuid)])
 296
 297     def test_mti(self):
 298         MtiItem = cbox.MtiItem
 299         song = Document.get_song()
 300         song.clear()
 301         tp = song.status()
 302         self.assertEqual(tp.tracks, [])
 303         self.assertEqual(tp.patterns, [])
 304         self.assertEqual(tp.mtis, [])
 305         song.set_mti(0, 120.0)
 306         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0)])
 307         song.set_mti(60, 150.0)
 308         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(60, 150.0, 0, 0)])
 309         song.set_mti(90, 180.0)
 310         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(60, 150.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 311         song.set_mti(60, 180.0)
 312         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(60, 180.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 313         song.set_mti(65, 210.0)
 314         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(60, 180.0, 0, 0), MtiItem(65, 210.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 315
 316         song.set_mti(60, 0.0, 0, 0)
 317         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(65, 210.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 318         song.set_mti(65, 0.0, 0, 0)
 319         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 320         song.set_mti(68, 0.0, 0, 0)
 321         self.assertEqual(song.status().mtis, [MtiItem(0, 120.0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 322         song.set_mti(0, 0.0, 0, 0)
 323         self.assertEqual(song.status().mtis, [MtiItem(0, 0, 0, 0), MtiItem(90, 180.0, 0, 0)])
 324         song.set_mti(90, 0.0, 0, 0)
 325         self.assertEqual(song.status().mtis, [MtiItem(0, 0, 0, 0)])
 326
 327     def test_error(self):
 328         thrown = False
 329         try:
 330             Document.get_scene().cmd('transpose', None, cbox)
 331         except ValueError as ve:
 332             self.assertTrue("class 'module'" in str(ve))
 333             thrown = True
 334         self.assertTrue(thrown)
 335
 336 unittest.main()
 337
 338 cbox.stop_audio()
 339 cbox.shutdown_engine()