updating some tests to fix random errors

test/algorithm_test.py

@@ -1,8 +1,8 @@
 import unittest
 import pedsp.algorithm as algorithm
 import numpy as np
+import random
 from random import randint
-
 from utility import generate_inputs
 
 
@@ -109,22 +109,22 @@ def test_linear_space(self):
 
     def test_linear_search(self):
         for data in generate_inputs(self.__number_inputs, self.__minimum_size, self.__maximum_size):
-            value = data[randint(0, len(data) - 1)]
+            value = random.choice(data)
             generated = algorithm.linear_search(data, value)
             reference = list(data).index(value)
             self.assertAlmostEqual(generated, reference)
 
     def test_binary_search(self):
         for data in generate_inputs(self.__number_inputs, self.__minimum_size, self.__maximum_size):
             data = np.sort(data)
-            value = data[randint(0, len(data) - 1)]
+            value = random.choice(data)
             generated = algorithm.binary_search(data, value)
             reference = list(data).index(value)
             self.assertAlmostEqual(generated, reference)
 
     def test_index_of(self):
         for data in generate_inputs(self.__number_inputs, self.__minimum_size, self.__maximum_size):
-            value = data[randint(0, len(data) - 1)]
+            value = random.choice(data)
             generated = algorithm.index_of(data, value)
             reference = list(data).index(value)
             self.assertAlmostEqual(generated, reference)
@@ -133,8 +133,8 @@ def test_equal(self):
         for data in generate_inputs(self.__number_inputs, self.__minimum_size, self.__maximum_size):
             duplicate = np.copy(data)
             self.assertTrue(algorithm.equal(data, duplicate))
-            for _ in range(randint(0, len(data))):
-                index = randint(0, len(data) - 1)
-                duplicate[index] = 2 * duplicate[index]
 
+            editions = random.randint(0, len(data) - 1)
+            indexes = random.sample(range(0, len(data) - 1), editions)
+            duplicate[indexes] = 2 * duplicate[indexes]
             self.assertFalse(algorithm.equal(data, duplicate))

test/spectral_features_test.py

@@ -44,7 +44,7 @@ def __spectral_entropy(psd):
     def test_spectral_centroid(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             ind = (np.arange(1, len(data) + 1)) * (fs/(2.0 * len(data)))
             generated = spectral.spectral_centroid(data, ind)
             centroid, _ = extractor.stSpectralCentroidAndSpread(data, fs)
@@ -55,7 +55,7 @@ def test_spectral_centroid(self):
     def test_spectral_spread(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             ind = (np.arange(1, len(data) + 1)) * (fs/(2.0 * len(data)))
             generated = spectral.spectral_spread(data, ind)
             _, spread = extractor.stSpectralCentroidAndSpread(data, fs)
@@ -65,7 +65,7 @@ def test_spectral_spread(self):
     def test_spectral_flux(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_flux(data, data)
             reference = extractor.stSpectralFlux(data, data)
             self.assertAlmostEqual(generated, reference)
@@ -74,39 +74,39 @@ def test_spectral_rolloff(self):
         for fs, data in self.__database:
             percentage = random.uniform(0.0, 1.0)
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_rolloff(data, percentage)
             reference = extractor.stSpectralRollOff(data, percentage, fs)
             self.assertAlmostEqual(generated, reference)
 
     def test_spectral_flatness(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_flatness(data)
             reference = self.__compute_flatness(data)
             self.assertAlmostEqual(generated, reference)
 
     def test_spectral_crest(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_crest(data)
             reference = self.__compute_crest(data)
             self.assertAlmostEqual(generated, reference)
 
     def test_spectral_kurtosis(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_kurtosis(data)
             reference = scipy.stats.mstats.kurtosis(data, fisher=False)
             self.assertAlmostEqual(generated, reference)
 
     def test_spectral_skewness(self):
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_skewness(data)
             reference = scipy.stats.mstats.skew(data)
             self.assertAlmostEqual(generated, reference)
@@ -115,7 +115,7 @@ def test_spectral_entropy(self):
         import math
         for fs, data in self.__database:
             _, data = scipy.signal.periodogram(data, fs)
-            data = data * 100
+            data = (data + utility.epsilon) * 100
             generated = spectral.spectral_entropy(data)
             reference = self.__spectral_entropy(data)
             self.assertAlmostEqual(generated, reference)

test/utility.py

@@ -5,6 +5,8 @@
 import os.path
 import soundfile as sf
 
+epsilon = 0.1
+
 def get_list_test_files():
     file_path = os.path.abspath(__file__)
     root = os.path.dirname(file_path)
@@ -19,7 +21,7 @@ def read_audio_test_files(number_inputs, minimum_size, maximum_size):
         wave, fs = sf.read(str(path))
         _, channels = wave.shape
         wave = wave.sum(axis=1) / channels
-        wave = wave.astype(np.float64)
+        wave = wave.astype(np.float64) + epsilon
         size = randint(min(minimum_size, len(wave)), min(maximum_size, len(wave)))
         starting = randint(0, len(wave) - size)
         wave = wave[starting:starting + size]
@@ -43,7 +45,7 @@ def generate_inputs(number_inputs, minimum_size, maximum_size):
     data = []
     for _ in range(number_inputs):
         size = randint(minimum_size, maximum_size)
-        data.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + 0.1)
+        data.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + epsilon)
     return data
 
 def generate_pair_inputs(number_inputs, minimum_size, maximum_size):
@@ -52,8 +54,8 @@ def generate_pair_inputs(number_inputs, minimum_size, maximum_size):
     second = []
     for _ in range(number_inputs):
         size = randint(minimum_size, maximum_size)
-        first.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + 0.1)
-        second.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + 0.1)
+        first.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + epsilon)
+        second.append(signals[randint(0, len(signals) - 1)](size).astype(np.float64) + epsilon)
     return first, second
 
 def generate_timestamps(init_t, n, sr):