From: Paul Brossier Date: Sun, 14 Apr 2013 22:59:11 +0000 (-0500) Subject: tests/: rename to test_ X-Git-Tag: 0.5.0~115^2~35 X-Git-Url: https://git.parisson.com/?a=commitdiff_plain;h=d5705f6b875f0d3f0546eed420946a922888c2bb;p=timeside.git tests/: rename to test_ --- diff --git a/tests/run_all_tests b/tests/run_all_tests index 444c1db..810a2ba 100755 --- a/tests/run_all_tests +++ b/tests/run_all_tests @@ -9,7 +9,7 @@ if __name__ == '__main__': if curdir == '': curdir = '.' files = os.listdir(curdir) modfiles = filter (lambda y: y.endswith('.py'), files) - modfiles = filter (lambda f: f.startswith('test'), modfiles) + modfiles = filter (lambda f: f.startswith('test_'), modfiles) # get module names modnames = map (lambda x: os.path.splitext(x)[0], modfiles) # import them diff --git a/tests/test_analyzing.py b/tests/test_analyzing.py new file mode 100755 index 0000000..2560a4f --- /dev/null +++ b/tests/test_analyzing.py @@ -0,0 +1,38 @@ +from timeside.decoder import * +from timeside.analyzer import * +from unit_timeside import * + +import os.path + +__all__ = ['TestAnalyzing'] + +class TestAnalyzing(TestCase): + "Test all analyzers" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + + def testDC(self): + "Test mean DC shift" + self.analyzer = MeanDCShift() + self.value = -0 + + def testMeanLevel(self): + "Test mean level" + self.analyzer = MeanLevel() + self.value = -9.856 + + def testMaxLevel(self): + "Test max level" + self.analyzer = MaxLevel() + self.value = -6.0209999999999999 + + def tearDown(self): + decoder = FileDecoder(self.source) + (decoder | self.analyzer).run() + self.assertEquals(self.analyzer.result(), self.value) + + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) + diff --git a/tests/test_component.py b/tests/test_component.py new file mode 100755 index 0000000..c5c3e31 --- /dev/null +++ b/tests/test_component.py @@ -0,0 +1,164 @@ +from timeside.component import * +from unit_timeside import * + +__all__ = ['TestComponentArchitecture'] + +class TestComponentArchitecture(TestCase): + "Test the component and interface system" + + def testOneInterface(self): + "Test a component implementing one interface" + self.assertSameList(implementations(I1), [C1]) + + def testTwoInterfaces(self): + "Test a component implementing two interfaces" + self.assertSameList(implementations(I2), [C2]) + self.assertSameList(implementations(I3), [C2]) + + def testTwoImplementations(self): + "Test an interface implemented by two components" + self.assertSameList(implementations(I4), [C3, C4]) + + def testInterfaceInheritance(self): + "Test whether a component implements an interface's parent" + self.assertSameList(implementations(I5), [C5]) + + def testImplementationInheritance(self): + "Test that a component doesn't implement the interface implemented by its parent" + self.assertSameList(implementations(I7), [C6]) + + def testImplementationRedundancy(self): + "Test implementation redundancy across inheritance" + self.assertSameList(implementations(I8), [C8, C9]) + + def testAbstractImplementation(self): + "Test abstract implementation" + self.assertSameList(implementations(I11), []) + self.assertSameList(implementations(I11, abstract=True), [C11]) + + def testInterfaceDoc(self): + "Test @interfacedoc decorator" + self.assertEquals(C10.test.__doc__, "testdoc") + + def testInterfaceDocStatic(self): + "Test @interfacedoc decorator on static method" + self.assertEquals(C10.teststatic.__doc__, "teststaticdoc") + + def testIntefaceDocReversed(self): + "Test @interfacedoc on static method (decorators reversed)" + + try: + + class BogusDoc1(Component): + implements(I10) + + @interfacedoc + @staticmethod + def teststatic(self): + pass + + self.fail("No error raised with reversed decorators") + + except ComponentError: + pass + + def testInterfaceDocBadMethod(self): + "Test @interfacedoc with unexistant method in interface" + + try: + class BogusDoc2(Component): + implements(I10) + + @interfacedoc + def nosuchmethod(self): + pass + + self.fail("No error raised when decorating an unexistant method") + + except ComponentError: + pass + +class I1(Interface): + pass + +class I2(Interface): + pass + +class I3(Interface): + pass + +class I4(Interface): + pass + +class I5(Interface): + pass + +class I6(I5): + pass + +class I7(Interface): + pass + +class I8(Interface): + pass + +class I9(I8): + pass + +class I10(Interface): + def test(self): + """testdoc""" + + @staticmethod + def teststatic(self): + """teststaticdoc""" + +class I11(Interface): + pass + +class C1(Component): + implements(I1) + +class C2(Component): + implements(I2, I3) + +class C3(Component): + implements(I4) + +class C4(Component): + implements(I4) + +class C5(Component): + implements(I6) + +class C6(Component): + implements(I7) + +class C7(C6): + pass + +class C8(Component): + implements(I8) + +class C9(Component): + implements(I8, I9) + +class C10(Component): + implements(I10) + + @interfacedoc + def test(self): + pass + + @staticmethod + @interfacedoc + def teststatic(self): + pass + +class C11(Component): + abstract() + implements(I11) + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) + diff --git a/tests/test_decoding.py b/tests/test_decoding.py new file mode 100755 index 0000000..84d7022 --- /dev/null +++ b/tests/test_decoding.py @@ -0,0 +1,172 @@ +#! /usr/bin/env python + +from timeside.decoder.core import FileDecoder +from unit_timeside import * + +import os.path + +class TestDecoding(TestCase): + "Test decoding features" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = None, None, None + + def testWav(self): + "Test wav decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + + self.expected_channels = 2 + self.expected_samplerate = 44100 + + def testWavMono(self): + "Test mono wav decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav") + + self.expected_channels = 1 + self.expected_samplerate = 44100 + + def testWav32k(self): + "Test 32kHz wav decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav") + + self.expected_channels = 2 + self.expected_samplerate = 32000 + + def testFlac(self): + "Test flac decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + + self.expected_channels = 2 + self.expected_samplerate = 44100 + + def testOgg(self): + "Test ogg decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + + self.expected_channels = 2 + self.expected_samplerate = 44100 + + def testMp3(self): + "Test mp3 decoding" + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + + self.expected_channels = 2 + self.expected_samplerate = 44100 + + def tearDown(self): + decoder = FileDecoder(self.source) + + decoder.setup(samplerate = self.samplerate, channels = self.channels, blocksize = self.blocksize) + + totalframes = 0. + + while True: + frames, eod = decoder.process() + totalframes += frames.shape[0] + if eod or decoder.eod: break + self.assertEquals(frames.shape[0], decoder.blocksize() ) + self.assertEquals(frames.shape[1], decoder.channels() ) + + ratio = decoder.output_samplerate / float(decoder.input_samplerate) + if 0: + print "input / output_samplerate:", decoder.input_samplerate, '/', decoder.output_samplerate, + print "ratio:", ratio + print "input / output_channels:", decoder.input_channels, decoder.output_channels + print "input_duration:", decoder.input_duration + print "input_totalframes:", decoder.input_totalframes + + if self.channels: + # when specified, check that the channels are the ones requested + self.assertEquals(self.channels, decoder.output_channels) + else: + # otherwise check that the channels are preserved, if not specified + self.assertEquals(decoder.input_channels, decoder.output_channels) + # and if we know the expected channels, check the output match + if self.expected_channels: + self.assertEquals(self.expected_channels, decoder.output_channels) + # do the same with the sampling rate + if self.samplerate: + self.assertEquals(self.samplerate, decoder.output_samplerate) + else: + self.assertEquals(decoder.input_samplerate, decoder.output_samplerate) + if self.expected_samplerate: + self.assertEquals(self.expected_samplerate, decoder.output_samplerate) + + # FIXME compute actual number of frames from file + if ratio == 1: + if os.path.splitext(self.source)[-1].lower() == '.mp3': + self.assertEquals(totalframes, 353664) + elif os.path.splitext(self.source)[-1].lower() == '.ogg': + self.assertEquals(totalframes, 352832) + else: + if '_32000.wav' in self.source: + self.assertEquals(totalframes, 256000) + else: + self.assertEquals(totalframes, 352800) + +class TestDecodingStereo(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = None, 2, None + +class TestDecodingMonoUpsampling(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 48000, None, None + +class TestDecodingMonoDownsampling(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 16000, None, None + +class TestDecodingStereoDownsampling(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 32000, 2, None + +class TestDecodingStereoUpsampling(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 96000, 2, None + +class TestDecodingShortBlock(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = None, None, 256 + +class TestDecodingLongBlock(TestDecoding): + + def setUp(self): + self.samplerate, self.channels, self.blocksize = None, None, 1024*8*2 + +class TestDecodingWrongFiles(TestCase): + "Test decoding features" + + def testMissingFile(self): + "Test decoding missing file" + self.source = os.path.join (os.path.dirname(__file__), "a_missing_file_blahblah.wav") + self.assertRaises(IOError, FileDecoder, self.source) + + def testDevNull(self): + "Test decoding dev null" + self.source = "/dev/null" + decoder = FileDecoder(self.source) + self.assertRaises(IOError, FileDecoder.setup, decoder) + + def testNoAudioStream(self): + "Test decoding file withouth audio stream" + self.source = __file__ + decoder = FileDecoder(self.source) + self.assertRaises(IOError, FileDecoder.setup, decoder) + + def testEmptyFile(self): + "Test decoding empty file" + import tempfile + self.tmpfile = tempfile.NamedTemporaryFile(delete=True) + self.source = self.tmpfile.name + decoder = FileDecoder(self.source) + self.assertRaises(IOError, FileDecoder.setup, decoder) + self.tmpfile.close() + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) diff --git a/tests/test_encoding.py b/tests/test_encoding.py new file mode 100755 index 0000000..eed01fd --- /dev/null +++ b/tests/test_encoding.py @@ -0,0 +1,270 @@ +from math import pi +from numpy import arange, sin, zeros +from unit_timeside import * + +import os.path +from os import unlink + +class TestEncoding(TestCase): + "Test encoding features" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 + import tempfile + self.tmpfile = tempfile.NamedTemporaryFile(delete=True) + self.sink = self.tmpfile.name + self.tmpfile.close() + + def testWav(self): + "Test wav encoding" + from timeside.encoder.wav import WavEncoder + self.encoder = WavEncoder(self.sink) + + def testVorbis(self): + "Test vorbis encoding" + from timeside.encoder.ogg import VorbisEncoder + self.encoder = VorbisEncoder(self.sink) + + def testMp3(self): + "Test mp3 encoding" + from timeside.encoder.mp3 import Mp3Encoder + self.encoder = Mp3Encoder(self.sink) + + # def testAac(self): + # "Test aac encoding" + # from timeside.encoder.m4a import AacEncoder + # self.encoder = AacEncoder(self.sink) + + def testFlac(self): + "Test flac encoding" + from timeside.encoder.flac import FlacEncoder + self.encoder = FlacEncoder(self.sink) + + # def testWebm(self): + # "Test webm encoding" + # from timeside.encoder.webm import WebMEncoder + # self.encoder = WebMEncoder(self.sink) + + def tearDown(self): + + self.encoder.setup(channels = self.channels, samplerate = self.samplerate) + + written_frames, eod = 0, False + total_frames = 3. * self.samplerate + block_size = self.blocksize + f0 = 800. + omega = 2. * pi * f0 / float(self.samplerate) + + while True: + remaining = total_frames - written_frames + if remaining >= block_size: + write_length = block_size + else: + write_length = remaining + eod = True + # build a sinusoid + frames = .75 * sin( omega * (arange(write_length) + written_frames) ) + # process encoder, writing to file + self.encoder.process(frames, eod) + written_frames += frames.shape[0] + if eod: + self.assertEquals(self.encoder.eod, True) + break + + self.encoder.release() + + if 0: + import commands + print commands.getoutput('sndfile-info ' + self.sink) + + self.assertEquals(written_frames, total_frames) + + if hasattr(self, 'tmpfile'): unlink(self.sink) + +class TestEncodingLongBlock(TestEncoding): + "Test encoding features with longer blocksize" + + def setUp(self): + super(TestEncodingLongBlock, self).setUp() + self.blocksize *= 8 + +class TestEncodingShortBlock(TestEncoding): + "Test encoding features with short blocksize" + + def setUp(self): + super(TestEncodingShortBlock, self).setUp() + self.blocksize = 64 + +class TestEncodingLowSamplerate(TestEncoding): + "Test encoding features with low samplerate" + + def setUp(self): + super(TestEncodingLowSamplerate, self).setUp() + self.samplerate = 8000 + +class TestEncodingHighSamplerate(TestEncoding): + "Test encoding features with high samplerate" + + def setUp(self): + super(TestEncodingHighSamplerate, self).setUp() + self.samplerate = 48000 + + def testMp3(self): + "Test mp3 encoding" + from timeside.encoder.mp3 import Mp3Encoder + self.encoder = Mp3Encoder(self.sink) + + +# class TestEncodingTooManyChannels(TestEncoding): +# "Test encoding features with high samplerate" + +# def setUp(self): +# super(TestEncodingTooManyChannels, self).setUp() +# self.samplerate = 192000 * 2 +# self.channels = 128 + +# def tearDown(self): +# self.encoder.setup(channels = self.channels, samplerate = self.samplerate) +# self.assertRaises(IOError, self.encoder.release) +# unlink(self.sink) + +class TestEncodingStereo(TestEncoding): + "Test encoding features with stereo" + + def setUp(self): + super(TestEncodingStereo, self).setUp() + self.channels = 2 + +class TestEncodingToDevNull(TestEncoding): + "Test encoding features with /dev/null" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 + self.sink = '/dev/null' + +class TestEncodingToDirectory(TestEncoding): + "Test encoding features to a directory" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 + import tempfile + self.sink = tempfile.mkdtemp() + + def testWav(self): + "Test wav encoding" + from timeside.encoder.wav import WavEncoder + self.assertRaises(IOError,WavEncoder,self.sink) + + def testVorbis(self): + "Test vorbis encoding" + from timeside.encoder.ogg import VorbisEncoder + self.assertRaises(IOError,VorbisEncoder,self.sink) + + def testMp3(self): + "Test mp3 encoding" + from timeside.encoder.mp3 import Mp3Encoder + self.assertRaises(IOError,Mp3Encoder,self.sink) + + # def testAac(self): + # "Test aac encoding" + # from timeside.encoder.m4a import AacEncoder + # self.assertRaises(IOError,AacEncoder,self.sink) + + def testFlac(self): + "Test flac encoding" + from timeside.encoder.flac import FlacEncoder + self.assertRaises(IOError,FlacEncoder,self.sink) + + # def testWebm(self): + # "Test webm encoding" + # from timeside.encoder.webm import WebMEncoder + # self.assertRaises(IOError,WebMEncoder,self.sink) + + def tearDown(self): + from os import rmdir + rmdir(self.sink) + +class TestEncodingOverwriteFails(TestCase): + "Test encoding features" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 + import tempfile + self.tmpfile = tempfile.NamedTemporaryFile(delete=True) + self.sink = self.tmpfile.name + + def testWav(self): + "Test wav encoding" + from timeside.encoder.wav import WavEncoder + self.assertRaises(IOError,WavEncoder,self.sink) + + def testVorbis(self): + "Test vorbis encoding" + from timeside.encoder.ogg import VorbisEncoder + self.assertRaises(IOError,VorbisEncoder,self.sink) + + def testMp3(self): + "Test mp3 encoding" + from timeside.encoder.mp3 import Mp3Encoder + self.assertRaises(IOError,Mp3Encoder,self.sink) + + # def testAac(self): + # "Test aac encoding" + # from timeside.encoder.m4a import AacEncoder + # self.assertRaises(IOError,AacEncoder,self.sink) + + def testFlac(self): + "Test flac encoding" + from timeside.encoder.flac import FlacEncoder + self.assertRaises(IOError,FlacEncoder,self.sink) + + def testWebm(self): + "Test webm encoding" + from timeside.encoder.webm import WebMEncoder + self.assertRaises(IOError,WebMEncoder,self.sink) + +class TestEncodingOverwriteForced(TestCase): + "Test encoding features" + + def setUp(self): + self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 + import tempfile + self.tmpfile = tempfile.NamedTemporaryFile(delete=True) + self.sink = self.tmpfile.name + + def testWav(self): + "Test wav encoding" + from timeside.encoder.wav import WavEncoder + self.encoder = WavEncoder(self.sink, overwrite = True) + + def testVorbis(self): + "Test vorbis encoding" + from timeside.encoder.ogg import VorbisEncoder + self.encoder = VorbisEncoder(self.sink, overwrite = True) + + def testMp3(self): + "Test mp3 encoding" + from timeside.encoder.mp3 import Mp3Encoder + self.encoder = Mp3Encoder(self.sink, overwrite = True) + + # def testAac(self): + # "Test aac encoding" + # from timeside.encoder.m4a import AacEncoder + # self.encoder = AacEncoder(self.sink, overwrite = True) + + def testFlac(self): + "Test flac encoding" + from timeside.encoder.flac import FlacEncoder + self.encoder = FlacEncoder(self.sink, overwrite = True) + + # def testWebm(self): + # "Test webm encoding" + # from timeside.encoder.webm import WebMEncoder + # self.encoder = WebMEncoder(self.sink, overwrite = True) + + def tearDown(self): + super(TestEncodingOverwriteForced, self).tearDown() + self.tmpfile.close() + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) diff --git a/tests/test_graphing.py b/tests/test_graphing.py new file mode 100755 index 0000000..ea39eda --- /dev/null +++ b/tests/test_graphing.py @@ -0,0 +1,146 @@ +from timeside.decoder.core import FileDecoder +from unit_timeside import * + +import os.path + +__all__ = ['TestGraphing'] + +class TestGraphing(TestCase): + "Test all graphers with various input media formats" + + def setUp(self): + pass + + # WAVEFORMS + def testWav2Waveform(self): + "Test WAV to Waveform" + from timeside.grapher.waveform import Waveform + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + self.image = "/tmp/test_waveform_sweep_wav.png" + self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testFlac2Waveform(self): + "Test FLAC to Waveform" + from timeside.grapher.waveform import Waveform + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + self.image = "/tmp/test_waveform_sweep_flac.png" + self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testMp32Waveform(self): + "Test MP3 to Waveform" + from timeside.grapher.waveform import Waveform + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + self.image = "/tmp/test_waveform_sweep_mp3.png" + self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testOgg2Waveform(self): + "Test OGG to Waveform" + from timeside.grapher.waveform import Waveform + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + self.image = "/tmp/test_waveform_sweep_ogg.png" + self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + # WAVEFORM SIMPLE + def testWav2WaveformSimple(self): + "Test WAV to WaveformSimple" + from timeside.grapher.waveform_simple import WaveformSimple + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + self.image = "/tmp/test_waveform_simple_sweep_wav.png" + self.grapher = WaveformSimple(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + # WAVEFORMS CONTOUR BLACK + def testWav2WaveformContourBlack(self): + "Test WAV to WaveformContourBlack" + from timeside.grapher.waveform_contour_bk import WaveformContourBlack + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + self.image = "/tmp/test_waveform_contour_bk_sweep_wav.png" + self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testFlac2WaveformContourBlack(self): + "Test FLAC to WaveformContourBlack" + from timeside.grapher.waveform_contour_bk import WaveformContourBlack + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + self.image = "/tmp/test_waveform_contour_bk_sweep_flac.png" + self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testMp32WaveformContourBlack(self): + "Test MP3 to WaveformContourBlack" + from timeside.grapher.waveform_contour_bk import WaveformContourBlack + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + self.image = "/tmp/test_waveform_contour_bk_sweep_mp3.png" + self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testOgg2WaveformContourBlack(self): + "Test OGG to WaveformContourBlack" + from timeside.grapher.waveform_contour_bk import WaveformContourBlack + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + self.image = "/tmp/test_waveform_contour_bk_sweep_ogg.png" + self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + # WAVEFORMS CONTOUR WHITE + def testWav2WaveformContourWhite(self): + "Test WAV to WaveformContourWhite" + from timeside.grapher.waveform_contour_wh import WaveformContourWhite + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + self.image = "/tmp/test_waveform_contour_wh_sweep_wav.png" + self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testFlac2WaveformContourWhite(self): + "Test FLAC to WaveformContourWhite" + from timeside.grapher.waveform_contour_wh import WaveformContourWhite + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + self.image = "/tmp/test_waveform_contour_wh_sweep_flac.png" + self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testMp32WaveformContourWhite(self): + "Test MP3 to WaveformContourWhite" + from timeside.grapher.waveform_contour_wh import WaveformContourWhite + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + self.image = "/tmp/test_waveform_contour_wh_sweep_mp3.png" + self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testOggWaveformContourWhite(self): + "Test OGG to WaveformContourWhite" + from timeside.grapher.waveform_contour_wh import WaveformContourWhite + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + self.image = "/tmp/test_waveform_contour_wh_sweep_ogg.png" + self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + + # SPECTROGRAMS + def testWav2Spectrogram(self): + "Test WAV to Spectrogram" + from timeside.grapher.spectrogram import Spectrogram + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + self.image = "/tmp/test_spectrogram_sweep_wav.png" + self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testMp32Spectrogram(self): + "Test MP3 to Spectrogram" + from timeside.grapher.spectrogram import Spectrogram + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + self.image = "/tmp/test_spectrogram_sweep_mp3.png" + self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testFlac2Spectrogram(self): + "Test FLAC to Spectrogram" + from timeside.grapher.spectrogram import Spectrogram + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + self.image = "/tmp/test_spectrogram_sweep_flac.png" + self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def testOgg2Spectrogram(self): + "Test OGG to Spectrogram" + from timeside.grapher.spectrogram import Spectrogram + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + self.image = "/tmp/test_spectrogram_sweep_ogg.png" + self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') + + def tearDown(self): + decoder = FileDecoder(self.source) + (decoder | self.grapher).run() + self.grapher.render(self.image) + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) + diff --git a/tests/test_inputadapter.py b/tests/test_inputadapter.py new file mode 100755 index 0000000..319d8a3 --- /dev/null +++ b/tests/test_inputadapter.py @@ -0,0 +1,70 @@ +from timeside.core import FixedSizeInputAdapter +from unit_timeside import * +import numpy + +class TestFixedSizeInputAdapter(TestCase): + "Test the fixed-sized input adapter" + + def assertIOEquals(self, adapter, input, input_eod, output, output_eod=None): + output = output[:] + output.reverse() + _eod = None + for buffer, _eod in adapter.process(input, input_eod): + a = output.pop() + if not numpy.array_equiv(buffer, a): + self.fail("\n-- Actual --\n%s\n -- Expected -- \n%s\n" % (str(buffer), str(a))) + + if _eod != output_eod: + self.fail("eod do not match: %s != %s", (str(_eod), str(output_eod))) + + if output: + self.fail("trailing expected data: %s" % output) + + def setUp(self): + self.data = numpy.arange(44).reshape(2,22).transpose() + + def testTwoChannels(self): + "Test simple stream with two channels" + adapter = FixedSizeInputAdapter(4, 2) + + self.assertEquals(len(self.data), adapter.blocksize(len(self.data))) + + self.assertIOEquals(adapter, self.data[0:1], False, []) + self.assertIOEquals(adapter, self.data[1:5], False, [self.data[0:4]], False) + self.assertIOEquals(adapter, self.data[5:12], False, [self.data[4:8], self.data[8:12]], False) + self.assertIOEquals(adapter, self.data[12:13], False, []) + self.assertIOEquals(adapter, self.data[13:14], False, []) + self.assertIOEquals(adapter, self.data[14:18], False, [self.data[12:16]], False) + self.assertIOEquals(adapter, self.data[18:20], False, [self.data[16:20]], False) + self.assertIOEquals(adapter, self.data[20:21], False, []) + self.assertIOEquals(adapter, self.data[21:22], True, [self.data[20:22]], True) + + def testPadding(self): + "Test automatic padding support" + adapter = FixedSizeInputAdapter(4, 2, pad=True) + + self.assertEquals(len(self.data) + 2, adapter.blocksize(len(self.data))) + + self.assertIOEquals(adapter, self.data[0:21], False, + [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]], + False) + + self.assertIOEquals(adapter, self.data[21:22], True, [[ + [20, 42], + [21, 43], + [0, 0], + [0, 0] + ]], True) + + def testSizeMultiple(self): + "Test a stream which contain a multiple number of buffers" + adapter = FixedSizeInputAdapter(4, 2) + + self.assertIOEquals(adapter, self.data[0:20], True, + [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]], + True) + + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) + diff --git a/tests/test_transcoding.py b/tests/test_transcoding.py new file mode 100755 index 0000000..0fedff2 --- /dev/null +++ b/tests/test_transcoding.py @@ -0,0 +1,137 @@ +from timeside.core import * +from timeside.decoder import * +from timeside.analyzer import * +from timeside.encoder import * +from timeside.api import * +from timeside.component import * + +from unit_timeside import * + +import os.path + +class TestTranscodingFromWav(TestCase): + "Test transcoding from wav" + + def tmpTarget(self): + import tempfile + self.tmpfile = tempfile.NamedTemporaryFile(delete=True) + self.target = self.tmpfile.name + self.tmpfile.close() + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") + + def testToWav(self): + "Test conversion to wav" + self.tmpTarget() + self.encoder = WavEncoder(self.target) + + def testToMp3(self): + "Test conversion to mp3" + self.tmpTarget() + self.encoder = Mp3Encoder(self.target) + + def testToOgg(self): + "Test conversion to ogg" + self.tmpTarget() + self.encoder = VorbisEncoder(self.target) + + # def testToWebM(self): + # "Test conversion to webm" + # self.tmpTarget() + # self.encoder = WebMEncoder(self.target) + + # def testToM4a(self): + # "Test conversion to m4a" + # self.tmpTarget() + # self.encoder = AacEncoder(self.target) + + def setUpDecoder(self): + self.decoder = FileDecoder(self.source) + self.decoder.setup() + self.channels = self.decoder.channels() + self.samplerate = self.decoder.samplerate() + + def setUpEncoder(self): + self.encoder.setup(channels = self.channels, samplerate = self.samplerate) + + def tearDown(self): + self.setUpDecoder() + self.setUpEncoder() + + totalframes = 0 + while True: + frames, eod = self.decoder.process() + self.encoder.process(frames, eod) + totalframes += frames.shape[0] + if eod or self.encoder.eod: break + + + #print self.channels, self.samplerate, totalframes + + self.encoder.release() + + decoder = FileDecoder(self.target) + decoder.setup() + written_frames = 0 + while True: + frames, eod = decoder.process() + written_frames += frames.shape[0] + if eod: break + + #print decoder.channels(), decoder.samplerate(), written_frames + + self.assertEquals(self.channels, decoder.channels()) + self.assertEquals(self.samplerate, decoder.samplerate()) + self.assertTrue(written_frames - totalframes >= 0) + + import os + os.unlink(self.target) + +class TestTranscodingFromAnotherWav(TestTranscodingFromWav): + "Test transcoding from another wav" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/guitar.wav") + +class TestTranscodingFromMp3(TestTranscodingFromWav): + "Test transcoding from mp3" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") + +class TestTranscodingFromFlac(TestTranscodingFromWav): + "Test transcoding from flac" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") + +class TestTranscodingFromOgg(TestTranscodingFromWav): + "Test transcoding from ogg" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") + +class TestTranscodingFromMonoWav(TestTranscodingFromWav): + "Test transcoding from a mono wav" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav") + +class TestTranscodingFrom32kHzWav(TestTranscodingFromWav): + "Test transcoding from a 32kHz wav" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav") + +class TestTranscodingFromMissingFile(TestTranscodingFromWav): + "Test transcoding from a missing file" + + def setUp(self): + self.source = os.path.join (os.path.dirname(__file__), "samples/unexisting.wav") + + def tearDown(self): + self.assertRaises(IOError, self.setUpDecoder) + +if __name__ == '__main__': + unittest.main(testRunner=TestRunner()) diff --git a/tests/testanalyzing.py b/tests/testanalyzing.py deleted file mode 100644 index 2560a4f..0000000 --- a/tests/testanalyzing.py +++ /dev/null @@ -1,38 +0,0 @@ -from timeside.decoder import * -from timeside.analyzer import * -from unit_timeside import * - -import os.path - -__all__ = ['TestAnalyzing'] - -class TestAnalyzing(TestCase): - "Test all analyzers" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - - def testDC(self): - "Test mean DC shift" - self.analyzer = MeanDCShift() - self.value = -0 - - def testMeanLevel(self): - "Test mean level" - self.analyzer = MeanLevel() - self.value = -9.856 - - def testMaxLevel(self): - "Test max level" - self.analyzer = MaxLevel() - self.value = -6.0209999999999999 - - def tearDown(self): - decoder = FileDecoder(self.source) - (decoder | self.analyzer).run() - self.assertEquals(self.analyzer.result(), self.value) - - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) - diff --git a/tests/testcomponent.py b/tests/testcomponent.py deleted file mode 100644 index c5c3e31..0000000 --- a/tests/testcomponent.py +++ /dev/null @@ -1,164 +0,0 @@ -from timeside.component import * -from unit_timeside import * - -__all__ = ['TestComponentArchitecture'] - -class TestComponentArchitecture(TestCase): - "Test the component and interface system" - - def testOneInterface(self): - "Test a component implementing one interface" - self.assertSameList(implementations(I1), [C1]) - - def testTwoInterfaces(self): - "Test a component implementing two interfaces" - self.assertSameList(implementations(I2), [C2]) - self.assertSameList(implementations(I3), [C2]) - - def testTwoImplementations(self): - "Test an interface implemented by two components" - self.assertSameList(implementations(I4), [C3, C4]) - - def testInterfaceInheritance(self): - "Test whether a component implements an interface's parent" - self.assertSameList(implementations(I5), [C5]) - - def testImplementationInheritance(self): - "Test that a component doesn't implement the interface implemented by its parent" - self.assertSameList(implementations(I7), [C6]) - - def testImplementationRedundancy(self): - "Test implementation redundancy across inheritance" - self.assertSameList(implementations(I8), [C8, C9]) - - def testAbstractImplementation(self): - "Test abstract implementation" - self.assertSameList(implementations(I11), []) - self.assertSameList(implementations(I11, abstract=True), [C11]) - - def testInterfaceDoc(self): - "Test @interfacedoc decorator" - self.assertEquals(C10.test.__doc__, "testdoc") - - def testInterfaceDocStatic(self): - "Test @interfacedoc decorator on static method" - self.assertEquals(C10.teststatic.__doc__, "teststaticdoc") - - def testIntefaceDocReversed(self): - "Test @interfacedoc on static method (decorators reversed)" - - try: - - class BogusDoc1(Component): - implements(I10) - - @interfacedoc - @staticmethod - def teststatic(self): - pass - - self.fail("No error raised with reversed decorators") - - except ComponentError: - pass - - def testInterfaceDocBadMethod(self): - "Test @interfacedoc with unexistant method in interface" - - try: - class BogusDoc2(Component): - implements(I10) - - @interfacedoc - def nosuchmethod(self): - pass - - self.fail("No error raised when decorating an unexistant method") - - except ComponentError: - pass - -class I1(Interface): - pass - -class I2(Interface): - pass - -class I3(Interface): - pass - -class I4(Interface): - pass - -class I5(Interface): - pass - -class I6(I5): - pass - -class I7(Interface): - pass - -class I8(Interface): - pass - -class I9(I8): - pass - -class I10(Interface): - def test(self): - """testdoc""" - - @staticmethod - def teststatic(self): - """teststaticdoc""" - -class I11(Interface): - pass - -class C1(Component): - implements(I1) - -class C2(Component): - implements(I2, I3) - -class C3(Component): - implements(I4) - -class C4(Component): - implements(I4) - -class C5(Component): - implements(I6) - -class C6(Component): - implements(I7) - -class C7(C6): - pass - -class C8(Component): - implements(I8) - -class C9(Component): - implements(I8, I9) - -class C10(Component): - implements(I10) - - @interfacedoc - def test(self): - pass - - @staticmethod - @interfacedoc - def teststatic(self): - pass - -class C11(Component): - abstract() - implements(I11) - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) - diff --git a/tests/testdecoding.py b/tests/testdecoding.py deleted file mode 100644 index d88026f..0000000 --- a/tests/testdecoding.py +++ /dev/null @@ -1,170 +0,0 @@ -from timeside.decoder.core import FileDecoder -from unit_timeside import * - -import os.path - -class TestDecoding(TestCase): - "Test decoding features" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = None, None, None - - def testWav(self): - "Test wav decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - - self.expected_channels = 2 - self.expected_samplerate = 44100 - - def testWavMono(self): - "Test mono wav decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav") - - self.expected_channels = 1 - self.expected_samplerate = 44100 - - def testWav32k(self): - "Test 32kHz wav decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav") - - self.expected_channels = 2 - self.expected_samplerate = 32000 - - def testFlac(self): - "Test flac decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - - self.expected_channels = 2 - self.expected_samplerate = 44100 - - def testOgg(self): - "Test ogg decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - - self.expected_channels = 2 - self.expected_samplerate = 44100 - - def testMp3(self): - "Test mp3 decoding" - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - - self.expected_channels = 2 - self.expected_samplerate = 44100 - - def tearDown(self): - decoder = FileDecoder(self.source) - - decoder.setup(samplerate = self.samplerate, channels = self.channels, blocksize = self.blocksize) - - totalframes = 0. - - while True: - frames, eod = decoder.process() - totalframes += frames.shape[0] - if eod or decoder.eod: break - self.assertEquals(frames.shape[0], decoder.blocksize() ) - self.assertEquals(frames.shape[1], decoder.channels() ) - - ratio = decoder.output_samplerate / float(decoder.input_samplerate) - if 0: - print "input / output_samplerate:", decoder.input_samplerate, '/', decoder.output_samplerate, - print "ratio:", ratio - print "input / output_channels:", decoder.input_channels, decoder.output_channels - print "input_duration:", decoder.input_duration - print "input_totalframes:", decoder.input_totalframes - - if self.channels: - # when specified, check that the channels are the ones requested - self.assertEquals(self.channels, decoder.output_channels) - else: - # otherwise check that the channels are preserved, if not specified - self.assertEquals(decoder.input_channels, decoder.output_channels) - # and if we know the expected channels, check the output match - if self.expected_channels: - self.assertEquals(self.expected_channels, decoder.output_channels) - # do the same with the sampling rate - if self.samplerate: - self.assertEquals(self.samplerate, decoder.output_samplerate) - else: - self.assertEquals(decoder.input_samplerate, decoder.output_samplerate) - if self.expected_samplerate: - self.assertEquals(self.expected_samplerate, decoder.output_samplerate) - - # FIXME compute actual number of frames from file - if ratio == 1: - if os.path.splitext(self.source)[-1].lower() == '.mp3': - self.assertEquals(totalframes, 353664) - elif os.path.splitext(self.source)[-1].lower() == '.ogg': - self.assertEquals(totalframes, 352832) - else: - if '_32000.wav' in self.source: - self.assertEquals(totalframes, 256000) - else: - self.assertEquals(totalframes, 352800) - -class TestDecodingStereo(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = None, 2, None - -class TestDecodingMonoUpsampling(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 48000, None, None - -class TestDecodingMonoDownsampling(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 16000, None, None - -class TestDecodingStereoDownsampling(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 32000, 2, None - -class TestDecodingStereoUpsampling(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 96000, 2, None - -class TestDecodingShortBlock(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = None, None, 256 - -class TestDecodingLongBlock(TestDecoding): - - def setUp(self): - self.samplerate, self.channels, self.blocksize = None, None, 1024*8*2 - -class TestDecodingWrongFiles(TestCase): - "Test decoding features" - - def testMissingFile(self): - "Test decoding missing file" - self.source = os.path.join (os.path.dirname(__file__), "a_missing_file_blahblah.wav") - self.assertRaises(IOError, FileDecoder, self.source) - - def testDevNull(self): - "Test decoding dev null" - self.source = "/dev/null" - decoder = FileDecoder(self.source) - self.assertRaises(IOError, FileDecoder.setup, decoder) - - def testNoAudioStream(self): - "Test decoding file withouth audio stream" - self.source = __file__ - decoder = FileDecoder(self.source) - self.assertRaises(IOError, FileDecoder.setup, decoder) - - def testEmptyFile(self): - "Test decoding empty file" - import tempfile - self.tmpfile = tempfile.NamedTemporaryFile(delete=True) - self.source = self.tmpfile.name - decoder = FileDecoder(self.source) - self.assertRaises(IOError, FileDecoder.setup, decoder) - self.tmpfile.close() - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) diff --git a/tests/testencoding.py b/tests/testencoding.py deleted file mode 100644 index eed01fd..0000000 --- a/tests/testencoding.py +++ /dev/null @@ -1,270 +0,0 @@ -from math import pi -from numpy import arange, sin, zeros -from unit_timeside import * - -import os.path -from os import unlink - -class TestEncoding(TestCase): - "Test encoding features" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 - import tempfile - self.tmpfile = tempfile.NamedTemporaryFile(delete=True) - self.sink = self.tmpfile.name - self.tmpfile.close() - - def testWav(self): - "Test wav encoding" - from timeside.encoder.wav import WavEncoder - self.encoder = WavEncoder(self.sink) - - def testVorbis(self): - "Test vorbis encoding" - from timeside.encoder.ogg import VorbisEncoder - self.encoder = VorbisEncoder(self.sink) - - def testMp3(self): - "Test mp3 encoding" - from timeside.encoder.mp3 import Mp3Encoder - self.encoder = Mp3Encoder(self.sink) - - # def testAac(self): - # "Test aac encoding" - # from timeside.encoder.m4a import AacEncoder - # self.encoder = AacEncoder(self.sink) - - def testFlac(self): - "Test flac encoding" - from timeside.encoder.flac import FlacEncoder - self.encoder = FlacEncoder(self.sink) - - # def testWebm(self): - # "Test webm encoding" - # from timeside.encoder.webm import WebMEncoder - # self.encoder = WebMEncoder(self.sink) - - def tearDown(self): - - self.encoder.setup(channels = self.channels, samplerate = self.samplerate) - - written_frames, eod = 0, False - total_frames = 3. * self.samplerate - block_size = self.blocksize - f0 = 800. - omega = 2. * pi * f0 / float(self.samplerate) - - while True: - remaining = total_frames - written_frames - if remaining >= block_size: - write_length = block_size - else: - write_length = remaining - eod = True - # build a sinusoid - frames = .75 * sin( omega * (arange(write_length) + written_frames) ) - # process encoder, writing to file - self.encoder.process(frames, eod) - written_frames += frames.shape[0] - if eod: - self.assertEquals(self.encoder.eod, True) - break - - self.encoder.release() - - if 0: - import commands - print commands.getoutput('sndfile-info ' + self.sink) - - self.assertEquals(written_frames, total_frames) - - if hasattr(self, 'tmpfile'): unlink(self.sink) - -class TestEncodingLongBlock(TestEncoding): - "Test encoding features with longer blocksize" - - def setUp(self): - super(TestEncodingLongBlock, self).setUp() - self.blocksize *= 8 - -class TestEncodingShortBlock(TestEncoding): - "Test encoding features with short blocksize" - - def setUp(self): - super(TestEncodingShortBlock, self).setUp() - self.blocksize = 64 - -class TestEncodingLowSamplerate(TestEncoding): - "Test encoding features with low samplerate" - - def setUp(self): - super(TestEncodingLowSamplerate, self).setUp() - self.samplerate = 8000 - -class TestEncodingHighSamplerate(TestEncoding): - "Test encoding features with high samplerate" - - def setUp(self): - super(TestEncodingHighSamplerate, self).setUp() - self.samplerate = 48000 - - def testMp3(self): - "Test mp3 encoding" - from timeside.encoder.mp3 import Mp3Encoder - self.encoder = Mp3Encoder(self.sink) - - -# class TestEncodingTooManyChannels(TestEncoding): -# "Test encoding features with high samplerate" - -# def setUp(self): -# super(TestEncodingTooManyChannels, self).setUp() -# self.samplerate = 192000 * 2 -# self.channels = 128 - -# def tearDown(self): -# self.encoder.setup(channels = self.channels, samplerate = self.samplerate) -# self.assertRaises(IOError, self.encoder.release) -# unlink(self.sink) - -class TestEncodingStereo(TestEncoding): - "Test encoding features with stereo" - - def setUp(self): - super(TestEncodingStereo, self).setUp() - self.channels = 2 - -class TestEncodingToDevNull(TestEncoding): - "Test encoding features with /dev/null" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 - self.sink = '/dev/null' - -class TestEncodingToDirectory(TestEncoding): - "Test encoding features to a directory" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 - import tempfile - self.sink = tempfile.mkdtemp() - - def testWav(self): - "Test wav encoding" - from timeside.encoder.wav import WavEncoder - self.assertRaises(IOError,WavEncoder,self.sink) - - def testVorbis(self): - "Test vorbis encoding" - from timeside.encoder.ogg import VorbisEncoder - self.assertRaises(IOError,VorbisEncoder,self.sink) - - def testMp3(self): - "Test mp3 encoding" - from timeside.encoder.mp3 import Mp3Encoder - self.assertRaises(IOError,Mp3Encoder,self.sink) - - # def testAac(self): - # "Test aac encoding" - # from timeside.encoder.m4a import AacEncoder - # self.assertRaises(IOError,AacEncoder,self.sink) - - def testFlac(self): - "Test flac encoding" - from timeside.encoder.flac import FlacEncoder - self.assertRaises(IOError,FlacEncoder,self.sink) - - # def testWebm(self): - # "Test webm encoding" - # from timeside.encoder.webm import WebMEncoder - # self.assertRaises(IOError,WebMEncoder,self.sink) - - def tearDown(self): - from os import rmdir - rmdir(self.sink) - -class TestEncodingOverwriteFails(TestCase): - "Test encoding features" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 - import tempfile - self.tmpfile = tempfile.NamedTemporaryFile(delete=True) - self.sink = self.tmpfile.name - - def testWav(self): - "Test wav encoding" - from timeside.encoder.wav import WavEncoder - self.assertRaises(IOError,WavEncoder,self.sink) - - def testVorbis(self): - "Test vorbis encoding" - from timeside.encoder.ogg import VorbisEncoder - self.assertRaises(IOError,VorbisEncoder,self.sink) - - def testMp3(self): - "Test mp3 encoding" - from timeside.encoder.mp3 import Mp3Encoder - self.assertRaises(IOError,Mp3Encoder,self.sink) - - # def testAac(self): - # "Test aac encoding" - # from timeside.encoder.m4a import AacEncoder - # self.assertRaises(IOError,AacEncoder,self.sink) - - def testFlac(self): - "Test flac encoding" - from timeside.encoder.flac import FlacEncoder - self.assertRaises(IOError,FlacEncoder,self.sink) - - def testWebm(self): - "Test webm encoding" - from timeside.encoder.webm import WebMEncoder - self.assertRaises(IOError,WebMEncoder,self.sink) - -class TestEncodingOverwriteForced(TestCase): - "Test encoding features" - - def setUp(self): - self.samplerate, self.channels, self.blocksize = 44100, 1, 1024 - import tempfile - self.tmpfile = tempfile.NamedTemporaryFile(delete=True) - self.sink = self.tmpfile.name - - def testWav(self): - "Test wav encoding" - from timeside.encoder.wav import WavEncoder - self.encoder = WavEncoder(self.sink, overwrite = True) - - def testVorbis(self): - "Test vorbis encoding" - from timeside.encoder.ogg import VorbisEncoder - self.encoder = VorbisEncoder(self.sink, overwrite = True) - - def testMp3(self): - "Test mp3 encoding" - from timeside.encoder.mp3 import Mp3Encoder - self.encoder = Mp3Encoder(self.sink, overwrite = True) - - # def testAac(self): - # "Test aac encoding" - # from timeside.encoder.m4a import AacEncoder - # self.encoder = AacEncoder(self.sink, overwrite = True) - - def testFlac(self): - "Test flac encoding" - from timeside.encoder.flac import FlacEncoder - self.encoder = FlacEncoder(self.sink, overwrite = True) - - # def testWebm(self): - # "Test webm encoding" - # from timeside.encoder.webm import WebMEncoder - # self.encoder = WebMEncoder(self.sink, overwrite = True) - - def tearDown(self): - super(TestEncodingOverwriteForced, self).tearDown() - self.tmpfile.close() - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) diff --git a/tests/testgraphing.py b/tests/testgraphing.py deleted file mode 100644 index ea39eda..0000000 --- a/tests/testgraphing.py +++ /dev/null @@ -1,146 +0,0 @@ -from timeside.decoder.core import FileDecoder -from unit_timeside import * - -import os.path - -__all__ = ['TestGraphing'] - -class TestGraphing(TestCase): - "Test all graphers with various input media formats" - - def setUp(self): - pass - - # WAVEFORMS - def testWav2Waveform(self): - "Test WAV to Waveform" - from timeside.grapher.waveform import Waveform - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - self.image = "/tmp/test_waveform_sweep_wav.png" - self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testFlac2Waveform(self): - "Test FLAC to Waveform" - from timeside.grapher.waveform import Waveform - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - self.image = "/tmp/test_waveform_sweep_flac.png" - self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testMp32Waveform(self): - "Test MP3 to Waveform" - from timeside.grapher.waveform import Waveform - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - self.image = "/tmp/test_waveform_sweep_mp3.png" - self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testOgg2Waveform(self): - "Test OGG to Waveform" - from timeside.grapher.waveform import Waveform - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - self.image = "/tmp/test_waveform_sweep_ogg.png" - self.grapher = Waveform(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - # WAVEFORM SIMPLE - def testWav2WaveformSimple(self): - "Test WAV to WaveformSimple" - from timeside.grapher.waveform_simple import WaveformSimple - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - self.image = "/tmp/test_waveform_simple_sweep_wav.png" - self.grapher = WaveformSimple(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - # WAVEFORMS CONTOUR BLACK - def testWav2WaveformContourBlack(self): - "Test WAV to WaveformContourBlack" - from timeside.grapher.waveform_contour_bk import WaveformContourBlack - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - self.image = "/tmp/test_waveform_contour_bk_sweep_wav.png" - self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testFlac2WaveformContourBlack(self): - "Test FLAC to WaveformContourBlack" - from timeside.grapher.waveform_contour_bk import WaveformContourBlack - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - self.image = "/tmp/test_waveform_contour_bk_sweep_flac.png" - self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testMp32WaveformContourBlack(self): - "Test MP3 to WaveformContourBlack" - from timeside.grapher.waveform_contour_bk import WaveformContourBlack - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - self.image = "/tmp/test_waveform_contour_bk_sweep_mp3.png" - self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testOgg2WaveformContourBlack(self): - "Test OGG to WaveformContourBlack" - from timeside.grapher.waveform_contour_bk import WaveformContourBlack - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - self.image = "/tmp/test_waveform_contour_bk_sweep_ogg.png" - self.grapher = WaveformContourBlack(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - # WAVEFORMS CONTOUR WHITE - def testWav2WaveformContourWhite(self): - "Test WAV to WaveformContourWhite" - from timeside.grapher.waveform_contour_wh import WaveformContourWhite - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - self.image = "/tmp/test_waveform_contour_wh_sweep_wav.png" - self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testFlac2WaveformContourWhite(self): - "Test FLAC to WaveformContourWhite" - from timeside.grapher.waveform_contour_wh import WaveformContourWhite - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - self.image = "/tmp/test_waveform_contour_wh_sweep_flac.png" - self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testMp32WaveformContourWhite(self): - "Test MP3 to WaveformContourWhite" - from timeside.grapher.waveform_contour_wh import WaveformContourWhite - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - self.image = "/tmp/test_waveform_contour_wh_sweep_mp3.png" - self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testOggWaveformContourWhite(self): - "Test OGG to WaveformContourWhite" - from timeside.grapher.waveform_contour_wh import WaveformContourWhite - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - self.image = "/tmp/test_waveform_contour_wh_sweep_ogg.png" - self.grapher = WaveformContourWhite(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - - # SPECTROGRAMS - def testWav2Spectrogram(self): - "Test WAV to Spectrogram" - from timeside.grapher.spectrogram import Spectrogram - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - self.image = "/tmp/test_spectrogram_sweep_wav.png" - self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testMp32Spectrogram(self): - "Test MP3 to Spectrogram" - from timeside.grapher.spectrogram import Spectrogram - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - self.image = "/tmp/test_spectrogram_sweep_mp3.png" - self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testFlac2Spectrogram(self): - "Test FLAC to Spectrogram" - from timeside.grapher.spectrogram import Spectrogram - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - self.image = "/tmp/test_spectrogram_sweep_flac.png" - self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def testOgg2Spectrogram(self): - "Test OGG to Spectrogram" - from timeside.grapher.spectrogram import Spectrogram - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - self.image = "/tmp/test_spectrogram_sweep_ogg.png" - self.grapher = Spectrogram(width=1024, height=256, bg_color=(0,0,0), color_scheme='default') - - def tearDown(self): - decoder = FileDecoder(self.source) - (decoder | self.grapher).run() - self.grapher.render(self.image) - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) - diff --git a/tests/testinputadapter.py b/tests/testinputadapter.py deleted file mode 100644 index 319d8a3..0000000 --- a/tests/testinputadapter.py +++ /dev/null @@ -1,70 +0,0 @@ -from timeside.core import FixedSizeInputAdapter -from unit_timeside import * -import numpy - -class TestFixedSizeInputAdapter(TestCase): - "Test the fixed-sized input adapter" - - def assertIOEquals(self, adapter, input, input_eod, output, output_eod=None): - output = output[:] - output.reverse() - _eod = None - for buffer, _eod in adapter.process(input, input_eod): - a = output.pop() - if not numpy.array_equiv(buffer, a): - self.fail("\n-- Actual --\n%s\n -- Expected -- \n%s\n" % (str(buffer), str(a))) - - if _eod != output_eod: - self.fail("eod do not match: %s != %s", (str(_eod), str(output_eod))) - - if output: - self.fail("trailing expected data: %s" % output) - - def setUp(self): - self.data = numpy.arange(44).reshape(2,22).transpose() - - def testTwoChannels(self): - "Test simple stream with two channels" - adapter = FixedSizeInputAdapter(4, 2) - - self.assertEquals(len(self.data), adapter.blocksize(len(self.data))) - - self.assertIOEquals(adapter, self.data[0:1], False, []) - self.assertIOEquals(adapter, self.data[1:5], False, [self.data[0:4]], False) - self.assertIOEquals(adapter, self.data[5:12], False, [self.data[4:8], self.data[8:12]], False) - self.assertIOEquals(adapter, self.data[12:13], False, []) - self.assertIOEquals(adapter, self.data[13:14], False, []) - self.assertIOEquals(adapter, self.data[14:18], False, [self.data[12:16]], False) - self.assertIOEquals(adapter, self.data[18:20], False, [self.data[16:20]], False) - self.assertIOEquals(adapter, self.data[20:21], False, []) - self.assertIOEquals(adapter, self.data[21:22], True, [self.data[20:22]], True) - - def testPadding(self): - "Test automatic padding support" - adapter = FixedSizeInputAdapter(4, 2, pad=True) - - self.assertEquals(len(self.data) + 2, adapter.blocksize(len(self.data))) - - self.assertIOEquals(adapter, self.data[0:21], False, - [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]], - False) - - self.assertIOEquals(adapter, self.data[21:22], True, [[ - [20, 42], - [21, 43], - [0, 0], - [0, 0] - ]], True) - - def testSizeMultiple(self): - "Test a stream which contain a multiple number of buffers" - adapter = FixedSizeInputAdapter(4, 2) - - self.assertIOEquals(adapter, self.data[0:20], True, - [self.data[0:4], self.data[4:8], self.data[8:12], self.data[12:16], self.data[16:20]], - True) - - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner()) - diff --git a/tests/testtranscoding.py b/tests/testtranscoding.py deleted file mode 100644 index 0fedff2..0000000 --- a/tests/testtranscoding.py +++ /dev/null @@ -1,137 +0,0 @@ -from timeside.core import * -from timeside.decoder import * -from timeside.analyzer import * -from timeside.encoder import * -from timeside.api import * -from timeside.component import * - -from unit_timeside import * - -import os.path - -class TestTranscodingFromWav(TestCase): - "Test transcoding from wav" - - def tmpTarget(self): - import tempfile - self.tmpfile = tempfile.NamedTemporaryFile(delete=True) - self.target = self.tmpfile.name - self.tmpfile.close() - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.wav") - - def testToWav(self): - "Test conversion to wav" - self.tmpTarget() - self.encoder = WavEncoder(self.target) - - def testToMp3(self): - "Test conversion to mp3" - self.tmpTarget() - self.encoder = Mp3Encoder(self.target) - - def testToOgg(self): - "Test conversion to ogg" - self.tmpTarget() - self.encoder = VorbisEncoder(self.target) - - # def testToWebM(self): - # "Test conversion to webm" - # self.tmpTarget() - # self.encoder = WebMEncoder(self.target) - - # def testToM4a(self): - # "Test conversion to m4a" - # self.tmpTarget() - # self.encoder = AacEncoder(self.target) - - def setUpDecoder(self): - self.decoder = FileDecoder(self.source) - self.decoder.setup() - self.channels = self.decoder.channels() - self.samplerate = self.decoder.samplerate() - - def setUpEncoder(self): - self.encoder.setup(channels = self.channels, samplerate = self.samplerate) - - def tearDown(self): - self.setUpDecoder() - self.setUpEncoder() - - totalframes = 0 - while True: - frames, eod = self.decoder.process() - self.encoder.process(frames, eod) - totalframes += frames.shape[0] - if eod or self.encoder.eod: break - - - #print self.channels, self.samplerate, totalframes - - self.encoder.release() - - decoder = FileDecoder(self.target) - decoder.setup() - written_frames = 0 - while True: - frames, eod = decoder.process() - written_frames += frames.shape[0] - if eod: break - - #print decoder.channels(), decoder.samplerate(), written_frames - - self.assertEquals(self.channels, decoder.channels()) - self.assertEquals(self.samplerate, decoder.samplerate()) - self.assertTrue(written_frames - totalframes >= 0) - - import os - os.unlink(self.target) - -class TestTranscodingFromAnotherWav(TestTranscodingFromWav): - "Test transcoding from another wav" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/guitar.wav") - -class TestTranscodingFromMp3(TestTranscodingFromWav): - "Test transcoding from mp3" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.mp3") - -class TestTranscodingFromFlac(TestTranscodingFromWav): - "Test transcoding from flac" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.flac") - -class TestTranscodingFromOgg(TestTranscodingFromWav): - "Test transcoding from ogg" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep.ogg") - -class TestTranscodingFromMonoWav(TestTranscodingFromWav): - "Test transcoding from a mono wav" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_mono.wav") - -class TestTranscodingFrom32kHzWav(TestTranscodingFromWav): - "Test transcoding from a 32kHz wav" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/sweep_32000.wav") - -class TestTranscodingFromMissingFile(TestTranscodingFromWav): - "Test transcoding from a missing file" - - def setUp(self): - self.source = os.path.join (os.path.dirname(__file__), "samples/unexisting.wav") - - def tearDown(self): - self.assertRaises(IOError, self.setUpDecoder) - -if __name__ == '__main__': - unittest.main(testRunner=TestRunner())