Changeset 41b985f for python/tests

Timestamp:

Mar 12, 2017, 11:26:24 AM (8 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

sampler

Children:

bde49c4a

Parents:

71f2e5f (diff), 67b6618 (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.

Message:

Merge 'origin/master' into sampler

Conflicts:

.travis.yml
Makefile
examples/aubionotes.c
examples/parse_args.h
python/demos/demo_timestretch_online.py
python/lib/moresetuptools.py
python/tests/test_source.py
setup.py
src/io/source.c

Location:

python/tests

Files:

• __init__.py (added)
• eval_pitch (modified) (1 diff)
• test_aubio.py (modified) (1 diff)
• test_fft.py (modified) (1 diff)
• test_filter.py (modified) (1 diff)
• test_filterbank.py (modified) (1 diff)
• test_midi2note.py (modified) (3 diffs)
• test_note2midi.py (modified) (4 diffs)
• test_notes.py (added)
• test_phasevoc.py (modified) (1 diff)
• test_sink.py (modified) (3 diffs)
• test_slicing.py (modified) (1 diff)
• test_source.py (modified) (5 diffs)

python/tests/eval_pitch

@@ -25 +25 @@
 import os.path
 import numpy
-from utils import array_from_text_file, array_from_yaml_file
+from .utils import array_from_text_file, array_from_yaml_file
 from aubio import source, pitch, freqtomidi
 

python/tests/test_aubio.py

@@ -10 +10 @@
         import aubio
 
+    def test_version(self):
+        """ test aubio.version """
+        import aubio
+        self.assertEqual('0', aubio.version[0])
+
 if __name__ == '__main__':
     main()

python/tests/test_fft.py

@@ -34 +34 @@
         fftgrain = f (timegrain)
         assert_equal ( fftgrain.norm, 0 )
-        assert_equal ( fftgrain.phas, 0 )
+        try:
+            assert_equal ( fftgrain.phas, 0 )
+        except AssertionError:
+            assert_equal (fftgrain.phas[fftgrain.phas > 0], +pi)
+            assert_equal (fftgrain.phas[fftgrain.phas < 0], -pi)
+            assert_equal (np.abs(fftgrain.phas[np.abs(fftgrain.phas) != pi]), 0)
+            self.skipTest('fft(fvec(%d)).phas != +0, ' % win_s \
+                    + 'This is expected when using fftw3 on powerpc.')
 
     def test_impulse(self):

python/tests/test_filter.py

@@ -4 +4 @@
 from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, digital_filter
-from utils import array_from_text_file
+from .utils import array_from_text_file
 
 class aubio_filter_test_case(TestCase):

python/tests/test_filterbank.py

@@ -6 +6 @@
 import numpy as np
 from aubio import cvec, filterbank, float_type
-from utils import array_from_text_file
+from .utils import array_from_text_file
 
 class aubio_filterbank_test_case(TestCase):

python/tests/test_midi2note.py

@@ -3 +3 @@
 
 from aubio import midi2note
+from nose2.tools import params
 import unittest
 
@@ -17 +18 @@
 class midi2note_good_values(unittest.TestCase):
 
-    def test_midi2note_known_values(self):
+    @params(*list_of_known_midis)
+    def test_midi2note_known_values(self, midi, note):
         " known values are correctly converted "
-        for midi, note in list_of_known_midis:
-            self.assertEqual ( midi2note(midi), note )
+        self.assertEqual ( midi2note(midi), note )
 
 class midi2note_wrong_values(unittest.TestCase):
@@ -41 +42 @@
 
 if __name__ == '__main__':
-    unittest.main()
+    import nose2
+    nose2.main()

python/tests/test_note2midi.py

@@ -5 +5 @@
 
 from aubio import note2midi, freq2note
+from nose2.tools import params
 import unittest
 
@@ -14 +15 @@
         ( 'B3', 59 ),
         ( 'B#3', 60 ),
+        ( 'C♯4', 61 ),
         ( 'A4', 69 ),
         ( 'A#4', 70 ),
+        ( 'A♯4', 70 ),
+        ( 'A\u266f4', 70 ),
         ( 'Bb4', 70 ),
         ( 'B♭4', 70 ),
+        ( 'B\u266d4', 70 ),
         ( 'G8', 115 ),
         ( 'G♯8', 116 ),
         ( 'G9', 127 ),
-        ( 'G\udd2a2', 45 ),
-        ( 'B\ufffd2', 45 ),
         ( 'A♮2', 45 ),
+        )
+
+list_of_known_notes_with_unicode_issues = (
+        ('C𝄪4', 62 ),
+        ('E𝄫4', 62 ),
+        )
+
+list_of_unknown_notes = (
+        ( 'G\udd2a2' ),
+        ( 'B\ufffd2' ),
+        ( 'B\u266e\u266e2' ),
+        ( 'B\u266f\u266d3' ),
+        ( 'B33' ),
+        ( 'C.3' ),
+        ( 'A' ),
+        ( '2' ),
         )
 
 class note2midi_good_values(unittest.TestCase):
 
-    def test_note2midi_known_values(self):
+    @params(*list_of_known_notes)
+    def test_note2midi_known_values(self, note, midi):
         " known values are correctly converted "
-        for note, midi in list_of_known_notes:
+        self.assertEqual ( note2midi(note), midi )
+
+    @params(*list_of_known_notes_with_unicode_issues)
+    def test_note2midi_known_values_with_unicode_issues(self, note, midi):
+        " known values are correctly converted, unless decoding is expected to fail"
+        try:
             self.assertEqual ( note2midi(note), midi )
+        except UnicodeEncodeError as e:
+            import sys
+            strfmt = "len(u'\\U0001D12A') != 1, excpected decoding failure | {:s} | {:s} {:s}"
+            strres = strfmt.format(e, sys.platform, sys.version)
+            # happens with: darwin 2.7.10, windows 2.7.12
+            if len('\U0001D12A') != 1 and sys.version[0] == '2':
+                self.skipTest(strres + " | upgrade to Python 3 to fix")
+            else:
+                raise
 
 class note2midi_wrong_values(unittest.TestCase):
@@ -67 +101 @@
         self.assertRaises(TypeError, note2midi, 123)
 
+    def test_note2midi_wrong_data_too_long(self):
+        " fails when passed a note with a note name longer than expected"
+        self.assertRaises(ValueError, note2midi, 'CB+-3')
+
+    @params(*list_of_unknown_notes)
+    def test_note2midi_unknown_values(self, note):
+        " unknown values throw out an error "
+        self.assertRaises(ValueError, note2midi, note)
 
 class freq2note_simple_test(unittest.TestCase):
@@ -75 +117 @@
 
 if __name__ == '__main__':
-    unittest.main()
+    import nose2
+    nose2.main()

python/tests/test_phasevoc.py

@@ -47 +47 @@
             assert_equal ( t, 0.)
             assert_equal ( s.norm, 0.)
-            assert_equal ( s.phas, 0.)
+            try:
+                assert_equal ( s.phas, 0 )
+            except AssertionError:
+                assert_equal (s.phas[s.phas > 0], +np.pi)
+                assert_equal (s.phas[s.phas < 0], -np.pi)
+                assert_equal (np.abs(s.phas[np.abs(s.phas) != np.pi]), 0)
+                self.skipTest('pvoc(fvec(%d)).phas != +0, ' % win_s \
+                        + 'This is expected when using fftw3 on powerpc.')
             assert_equal ( r, 0.)
 

python/tests/test_sink.py

@@ -5 +5 @@
 from numpy.testing import TestCase
 from aubio import fvec, source, sink
-from utils import list_all_sounds, get_tmp_sink_path, del_tmp_sink_path
+from .utils import list_all_sounds, get_tmp_sink_path, del_tmp_sink_path
+
+import warnings
+warnings.filterwarnings('ignore', category=UserWarning, append=True)
 
 list_of_sounds = list_all_sounds('sounds')
@@ -26 +29 @@
         if not len(list_of_sounds):
             self.skipTest('add some sound files in \'python/tests/sounds\'')
+
+    def test_wrong_filename(self):
+        with self.assertRaises(RuntimeError):
+            sink('')
+
+    def test_wrong_samplerate(self):
+        with self.assertRaises(RuntimeError):
+            sink(get_tmp_sink_path(), -1)
+
+    def test_wrong_samplerate_too_large(self):
+        with self.assertRaises(RuntimeError):
+            sink(get_tmp_sink_path(), 1536001, 2)
+
+    def test_wrong_channels(self):
+        with self.assertRaises(RuntimeError):
+            sink(get_tmp_sink_path(), 44100, -1)
+
+    def test_wrong_channels_too_large(self):
+        with self.assertRaises(RuntimeError):
+            sink(get_tmp_sink_path(), 44100, 202020)
 
     def test_many_sinks(self):
@@ -94 +117 @@
         del_tmp_sink_path(sink_path)
 
+    def test_read_with(self):
+        sink_path =get_tmp_sink_path()
+        vec = fvec(128)
+        with sink(sink_path, samplerate) as g:
+            for i in range(10):
+                g(vec, 128)
+
 if __name__ == '__main__':
     main()

python/tests/test_slicing.py

@@ -4 +4 @@
 from numpy.testing import TestCase, assert_equal
 from aubio import slice_source_at_stamps
-from utils import count_files_in_directory, get_default_test_sound
-from utils import count_samples_in_directory, count_samples_in_file
+from .utils import count_files_in_directory, get_default_test_sound
+from .utils import count_samples_in_directory, count_samples_in_file
 
 import tempfile

python/tests/test_source.py

@@ -5 +5 @@
 from numpy.testing import TestCase, assert_equal
 from aubio import source
-from utils import list_all_sounds
+from .utils import list_all_sounds
 import numpy as np
 
@@ -57 +57 @@
             if read < f.hop_size:
                 assert_equal(samples[read:], 0)
-                if 'brownnoise' in f.uri:
-                    self.assertEquals(np.count_nonzero(samples[:read]), read)
                 break
         #result_str = "read {:.2f}s ({:d} frames in {:d} blocks at {:d}Hz) from {:s}"
@@ -72 +70 @@
             self.skipTest('failed opening with hop_s = {:d}, samplerate = {:d} ({:s})'.format(hop_size, samplerate, str(e)))
         assert f.samplerate != 0
-        self.read_from_source(f)
+        read_frames = self.read_from_source(f)
+        if 'f_' in soundfile and samplerate == 0:
+            import re
+            f = re.compile('.*_\([0:9]*f\)_.*')
+            match_f = re.findall('([0-9]*)f_', soundfile)
+            if len(match_f) == 1:
+                expected_frames = int(match_f[0])
+                self.assertEqual(expected_frames, read_frames)
 
     @params(*list_of_sounds)
@@ -159 +164 @@
             if read < f.hop_size:
                 assert_equal(samples[:,read:], 0)
-                if 'brownnoise' in f.uri:
-                    self.assertEquals(np.count_nonzero(samples[:,:read]), read)
                 break
         #result_str = "read {:.2f}s ({:d} frames in {:d} channels and {:d} blocks at {:d}Hz) from {:s}"
@@ -167 +170 @@
         return total_frames
 
+class aubio_source_with(aubio_source_test_case_base):
+
+    #@params(*list_of_sounds)
+    @params(*list_of_sounds)
+    def test_read_from_mono(self, filename):
+        total_frames = 0
+        hop_size = 2048
+        with source(filename, 0, hop_size) as input_source:
+            assert_equal(input_source.hop_size, hop_size)
+            #assert_equal(input_source.samplerate, samplerate)
+            total_frames = 0
+            for frames in input_source:
+                total_frames += frames.shape[-1]
+            # check we read as many samples as we expected
+            assert_equal(total_frames, input_source.duration)
+
 if __name__ == '__main__':
     main()