Changeset f264b17 for python/tests/test_fvec.py

Timestamp:

Jun 22, 2016, 1:00:10 PM (8 years ago)

Author:

Paul Brossier <piem@piem.org>

Branches:

feature/autosink, feature/cnn, feature/cnn_org, feature/constantq, feature/crepe, feature/crepe_org, feature/pitchshift, feature/pydocstrings, feature/timestretch, fix/ffmpeg5, master, pitchshift, sampler, timestretch, yinfft+

Children:

4b9443c4

Parents:

60fc05b (diff), 6769586 (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 branch 'master' into notes

File:

• python/tests/test_fvec.py (modified) (3 diffs)

python/tests/test_fvec.py

@@ -1 +1 @@
 #! /usr/bin/env python
 
-from numpy.testing import TestCase, run_module_suite
-from numpy.testing import assert_equal, assert_almost_equal
+from unittest import main
+import numpy as np
+from numpy.testing import TestCase, assert_equal, assert_almost_equal
 from aubio import fvec, zero_crossing_rate, alpha_norm, min_removal
-from numpy import array, shape
+from aubio import float_type
+
+wrong_type = 'float32' if float_type == 'float64' else 'float64'
 
 default_size = 512
@@ -12 +15 @@
     def test_vector_created_with_zeroes(self):
         a = fvec(10)
-        assert a.dtype == 'float32'
+        assert a.dtype == float_type
         assert a.shape == (10,)
-        assert_equal (a, 0)
+        assert_equal(a, 0)
 
     def test_vector_create_with_list(self):
-        a = fvec([0,1,2,3])
-        assert a.dtype == 'float32'
+        a = fvec([0, 1, 2, 3])
+        assert a.dtype == float_type
         assert a.shape == (4,)
-        assert_equal (range(4), a)
+        assert_equal(list(range(4)), a)
 
     def test_vector_assign_element(self):
@@ -35 +38 @@
     def test_vector(self):
         a = fvec()
-        a, len(a) #a.length
-        a[0]
-        array(a)
+        len(a)
+        _ = a[0]
+        np.array(a)
+        a = fvec(1)
         a = fvec(10)
-        a = fvec(1)
-        a.T
-        array(a).T
-        a = range(len(a))
+        _ = a.T
 
-    def test_wrong_values(self):
-        self.assertRaises (ValueError, fvec, -10)
-  
+class aubio_fvec_wrong_values(TestCase):
+
+    def test_negative_length(self):
+        """ test creating fvec with negative length fails (pure python) """
+        self.assertRaises(ValueError, fvec, -10)
+
+    def test_zero_length(self):
+        """ test creating fvec with zero length fails (pure python) """
+        self.assertRaises(ValueError, fvec, 0)
+
+    def test_out_of_bound(self):
+        """ test assiging fvec out of bounds fails (pure python) """
         a = fvec(2)
-        self.assertRaises (IndexError, a.__getitem__, 3)
-        self.assertRaises (IndexError, a.__getitem__, 2)
+        self.assertRaises(IndexError, a.__getitem__, 3)
+        self.assertRaises(IndexError, a.__getitem__, 2)
 
-    def test_alpha_norm_of_fvec(self):
-        a = fvec(2)
-        self.assertEquals (alpha_norm(a, 1), 0)
-        a[0] = 1
-        self.assertEquals (alpha_norm(a, 1), 0.5)
-        a[1] = 1
-        self.assertEquals (alpha_norm(a, 1), 1)
-        a = array([0, 1], dtype='float32')
-        from math import sqrt
-        assert_almost_equal (alpha_norm(a, 2), sqrt(2)/2.)
+class aubio_wrong_fvec_input(TestCase):
+    """ uses min_removal to test PyAubio_IsValidVector """
 
-    def test_alpha_norm_of_none(self):
-        self.assertRaises (ValueError, alpha_norm, None, 1)
+    def test_no_input(self):
+        self.assertRaises(TypeError, min_removal)
 
-    def test_alpha_norm_of_array_of_float32(self):
-        # check scalar fails
-        a = array(1, dtype = 'float32')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        # check 2d array fails
-        a = array([[2],[4]], dtype = 'float32')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        # check 1d array
-        a = array(range(10), dtype = 'float32')
-        self.assertEquals (alpha_norm(a, 1), 4.5)
+    def test_none(self):
+        self.assertRaises(ValueError, min_removal, None)
 
-    def test_alpha_norm_of_array_of_int(self):
-        a = array(1, dtype = 'int')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        a = array([[[1,2],[3,4]]], dtype = 'int')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        a = array(range(10), dtype = 'int')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_wrong_scalar(self):
+        a = np.array(10, dtype=float_type)
+        self.assertRaises(ValueError, min_removal, a)
 
-    def test_alpha_norm_of_array_of_string (self):
-        a = "hello"
-        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_wrong_dimensions(self):
+        a = np.array([[[1, 2], [3, 4]]], dtype=float_type)
+        self.assertRaises(ValueError, min_removal, a)
+
+    def test_wrong_array_size(self):
+        x = np.array([], dtype=float_type)
+        self.assertRaises(ValueError, min_removal, x)
+
+    def test_wrong_type(self):
+        a = np.zeros(10, dtype=wrong_type)
+        self.assertRaises(ValueError, min_removal, a)
+
+    def test_wrong_list_input(self):
+        self.assertRaises(ValueError, min_removal, [0., 1.])
+
+    def test_good_input(self):
+        a = np.zeros(10, dtype=float_type)
+        assert_equal(np.zeros(10, dtype=float_type), min_removal(a))
+
+class aubio_alpha_norm(TestCase):
+
+    def test_alpha_norm_of_random(self):
+        x = np.random.rand(1024).astype(float_type)
+        alpha = np.random.rand() * 5.
+        x_alpha_norm = (np.sum(np.abs(x)**alpha)/len(x))**(1/alpha)
+        assert_almost_equal(alpha_norm(x, alpha), x_alpha_norm, decimal = 5)
+
+class aubio_zero_crossing_rate_test(TestCase):
 
     def test_zero_crossing_rate(self):
-        a = array([0,1,-1], dtype='float32')
-        assert_almost_equal (zero_crossing_rate(a), 1./3. )
-        a = array([0.]*100, dtype='float32')
-        self.assertEquals (zero_crossing_rate(a), 0 )
-        a = array([-1.]*100, dtype='float32')
-        self.assertEquals (zero_crossing_rate(a), 0 )
-        a = array([1.]*100, dtype='float32')
-        self.assertEquals (zero_crossing_rate(a), 0 )
+        a = np.array([0, 1, -1], dtype=float_type)
+        assert_almost_equal(zero_crossing_rate(a), 1./3.)
 
-    def test_alpha_norm_of_array_of_float64(self):
-        # check scalar fail
-        a = array(1, dtype = 'float64')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        # check 3d array fail
-        a = array([[[1,2],[3,4]]], dtype = 'float64')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        # check float64 1d array fail
-        a = array(range(10), dtype = 'float64')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
-        # check float64 2d array fail
-        a = array([range(10), range(10)], dtype = 'float64')
-        self.assertRaises (ValueError, alpha_norm, a, 1)
+    def test_zero_crossing_rate_zeros(self):
+        a = np.zeros(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+
+    def test_zero_crossing_rate_minus_ones(self):
+        a = np.ones(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+
+    def test_zero_crossing_rate_plus_ones(self):
+        a = np.ones(100, dtype=float_type)
+        self.assertEqual(zero_crossing_rate(a), 0)
+
+class aubio_fvec_min_removal(TestCase):
 
     def test_fvec_min_removal_of_array(self):
-        a = array([20,1,19], dtype='float32')
+        a = np.array([20, 1, 19], dtype=float_type)
         b = min_removal(a)
-        assert_equal (array(b), [19, 0, 18])
-        assert_equal (b, [19, 0, 18])
-        assert_equal (a, b)
-        a[0] = 0
-        assert_equal (a, b)
+        assert_equal(b, [19, 0, 18])
 
-    def test_fvec_min_removal_of_array_float64(self):
-        a = array([20,1,19], dtype='float64')
-        self.assertRaises (ValueError, min_removal, a)
+class aubio_fvec_test_memory(TestCase):
 
-    def test_fvec_min_removal_of_fvec(self):
-        a = fvec(3)
-        a = array([20, 1, 19], dtype = 'float32')
-        b = min_removal(a)
-        assert_equal (array(b), [19, 0, 18])
-        assert_equal (b, [19, 0, 18])
-        assert_equal (a, b)
+    def test_pass_to_numpy(self):
+        a = fvec(10)
+        a[:] = 1.
+        b = a
+        del a
+        assert_equal(b, 1.)
+        c = fvec(10)
+        c = b
+        del b
+        assert_equal(c, 1.)
+        del c
 
 if __name__ == '__main__':
-    from unittest import main
     main()