3 files changed, 122 insertions, 16 deletions
diff --git a/gr-analog/python/analog/CMakeLists.txt b/gr-analog/python/analog/CMakeLists.txt
index ba3dfb5fc3..4c5d24f4c4 100644
--- a/gr-analog/python/analog/CMakeLists.txt
+++ b/gr-analog/python/analog/CMakeLists.txt
@@ -47,6 +47,11 @@ if(ENABLE_TESTING)
   set(GR_TEST_LIBRARY_DIRS "")
   set(GR_TEST_PYTHON_DIRS
     ${CMAKE_BINARY_DIR}/gnuradio-runtime/python
+    ${CMAKE_BINARY_DIR}/gnuradio-runtime/swig
+    ${CMAKE_BINARY_DIR}/gr-analog/swig	
+    ${CMAKE_BINARY_DIR}/gr-fft/swig	
+    ${CMAKE_BINARY_DIR}/gr-filter/swig	
+    ${CMAKE_BINARY_DIR}/gr-blocks/swig		
     )
 
   include(GrTest)
diff --git a/gr-analog/python/analog/qa_fastnoise.py b/gr-analog/python/analog/qa_fastnoise.py
index e90fcfd96e..f712d66ca7 100644
--- a/gr-analog/python/analog/qa_fastnoise.py
+++ b/gr-analog/python/analog/qa_fastnoise.py
@@ -20,33 +20,120 @@
 # Boston, MA 02110-1301, USA.
 #
 
+from gnuradio import gr, gr_unittest, analog, blocks
+import numpy
 
-from gnuradio import gr, gr_unittest, analog
 
 class test_fastnoise_source(gr_unittest.TestCase):
 
     def setUp (self):
-        self.tb = gr.top_block ()
+
+        self.num = 2**22
+        self.num_items = 10**6
+        self.default_args = {"samples": self.num, "seed": 43, "ampl": 1}
 
     def tearDown (self):
-        self.tb = None
+        pass
+
+    def run_test_real(self, form):
+        """ Run test case with float input/output
+        """
+        tb = gr.top_block()
+        src = analog.fastnoise_source_f(type=form, **self.default_args)
+        head = blocks.head(nitems=self.num_items, sizeof_stream_item=gr.sizeof_float)
+        sink = blocks.vector_sink_f()
+        tb.connect(src, head, sink)
+        tb.run()
+        return numpy.array(sink.data())
+
+    def run_test_complex(self, form):
+        """ Run test case with complex input/output
+        """
+        tb = gr.top_block()
+        src = analog.fastnoise_source_c(type=form, **self.default_args)
+        head = blocks.head(nitems=self.num_items, sizeof_stream_item=gr.sizeof_gr_complex)
+        sink = blocks.vector_sink_c()
+        tb.connect(src, head, sink)
+        tb.run()
+        return numpy.array(sink.data())
+
+    def test_001_real_uniform_moments(self):
+
+        data = self.run_test_real(analog.GR_UNIFORM)
+
+        self.assertAlmostEqual(min(data), -1, places=4)
+        self.assertAlmostEqual(max(data), 1, places=4)
+
+        # mean, variance
+        self.assertAlmostEqual(data.mean(), 0, places=2)
+        self.assertAlmostEqual(data.var(), (1-(-1))**2./12, places=3)
+
+    def test_001_real_gaussian_moments(self):
+        data = self.run_test_real(analog.GR_GAUSSIAN)
+
+        # mean, variance
+        self.assertAlmostEqual(data.mean(), 0, places=2)
+        self.assertAlmostEqual(data.var(), 1, places=2)
 
-    def test_001(self):
-        # Just confirm that we can instantiate a noise source
-        op = analog.fastnoise_source_f(analog.GR_GAUSSIAN, 10, 10)
+    def test_001_real_laplacian_moments(self):
+        data = self.run_test_real(analog.GR_LAPLACIAN)
 
-    def test_002(self):
-        # Test get methods
-        set_type = analog.GR_GAUSSIAN
-        set_ampl = 10
-        op = analog.fastnoise_source_f(set_type, set_ampl, 10)
-        get_type = op.type()
-        get_ampl = op.amplitude()
+        # mean, variance
+        self.assertAlmostEqual(data.mean(), 0, places=2)
+        self.assertAlmostEqual(data.var(), 2, places=2)
 
-        self.assertEqual(get_type, set_type)
-        self.assertEqual(get_ampl, set_ampl)
+    def test_001_complex_uniform_moments(self):
+        data = self.run_test_complex(analog.GR_UNIFORM)
 
+        # mean, variance
+        self.assertAlmostEqual(data.real.mean(), 0, places=2)
+        self.assertAlmostEqual(data.real.var(), 0.5*(1-(-1))**2./12, places=3)
 
+        self.assertAlmostEqual(data.imag.mean(), 0, places=2)
+        self.assertAlmostEqual(data.imag.var(), 0.5*(1-(-1))**2./12, places=3)
+
+    def test_001_complex_gaussian_moments(self):
+        data = self.run_test_complex(analog.GR_GAUSSIAN)
+
+        # mean, variance
+        self.assertAlmostEqual(data.real.mean(), 0, places=2)
+        self.assertAlmostEqual(data.real.var(), 0.5, places=2)
+
+        self.assertAlmostEqual(data.imag.mean(), 0, places=2)
+        self.assertAlmostEqual(data.imag.var(), 0.5, places=2)
+
+    def test_002_real_uniform_reproducibility(self):
+        data1 = self.run_test_real(analog.GR_UNIFORM)
+        data2 = self.run_test_real(analog.GR_UNIFORM)
+
+        # It's pseudoramdo thus must be equal
+        self.assertTrue(numpy.array_equal(data1, data2))
+
+    def test_002_real_gaussian_reproducibility(self):
+        data1 = self.run_test_real(analog.GR_GAUSSIAN)
+        data2 = self.run_test_real(analog.GR_GAUSSIAN)
+
+        self.assertTrue(numpy.array_equal(data1, data2))
+
+    def test_003_real_uniform_pool(self):
+        src = analog.fastnoise_source_f(type=analog.GR_UNIFORM, **self.default_args)
+        src2 = analog.fastnoise_source_f(type=analog.GR_UNIFORM, **self.default_args)
+        self.assertTrue(numpy.array_equal(numpy.array(src.samples()), numpy.array(src2.samples())))
+    def test_003_real_gaussian_pool(self):
+        src = analog.fastnoise_source_f(type=analog.GR_GAUSSIAN, **self.default_args)
+        src2 = analog.fastnoise_source_f(type=analog.GR_GAUSSIAN, **self.default_args)
+        self.assertTrue(numpy.array_equal(numpy.array(src.samples()), numpy.array(src2.samples())))
+    def test_003_cmplx_gaussian_pool(self):
+        src = analog.fastnoise_source_c(type=analog.GR_GAUSSIAN, **self.default_args)
+        src2 = analog.fastnoise_source_c(type=analog.GR_GAUSSIAN, **self.default_args)
+        self.assertTrue(numpy.array_equal(numpy.array(src.samples()), numpy.array(src2.samples())))
+    def test_003_cmplx_uniform_pool(self):
+        src = analog.fastnoise_source_c(type=analog.GR_UNIFORM, **self.default_args)
+        src2 = analog.fastnoise_source_c(type=analog.GR_UNIFORM, **self.default_args)
+        self.assertTrue(numpy.array_equal(numpy.array(src.samples()), numpy.array(src2.samples())))
+    def test_003_real_laplacian_pool(self):
+        src = analog.fastnoise_source_f(type=analog.GR_LAPLACIAN, **self.default_args)
+        src2 = analog.fastnoise_source_f(type=analog.GR_LAPLACIAN, **self.default_args)
+        self.assertTrue(numpy.array_equal(numpy.array(src.samples()), numpy.array(src2.samples())))
 if __name__ == '__main__':
     gr_unittest.run(test_fastnoise_source, "test_fastnoise_source.xml")
-
diff --git a/gr-analog/python/analog/qa_sig_source.py b/gr-analog/python/analog/qa_sig_source.py
index a38db29280..8b239fc070 100644
--- a/gr-analog/python/analog/qa_sig_source.py
+++ b/gr-analog/python/analog/qa_sig_source.py
@@ -84,6 +84,20 @@ class test_sig_source(gr_unittest.TestCase):
         dst_data = dst1.data()
         self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
 
+    def test_cosine_c(self):
+        tb = self.tb
+        sqrt2 = math.sqrt(2) / 2
+        sqrt2j = 1j * math.sqrt(2) / 2
+        expected_result = (1, sqrt2 + sqrt2j, 1j, -sqrt2 + sqrt2j, -1, -sqrt2 - sqrt2j, -1j, sqrt2 - sqrt2j, 1)
+        src1 = analog.sig_source_c(8, analog.GR_COS_WAVE, 1.0, 1.0)
+        op = blocks.head(gr.sizeof_gr_complex, 9)
+        dst1 = blocks.vector_sink_c()
+        tb.connect(src1, op)
+        tb.connect(op, dst1)
+        tb.run()
+        dst_data = dst1.data()
+        self.assertFloatTuplesAlmostEqual(expected_result, dst_data, 5)
+
     def test_sqr_c(self):
         tb = self.tb			#arg6 is a bit before -PI/2
         expected_result = (1j, 1j, 0, 0, 1, 1, 1+0j, 1+1j, 1j)