libs/audiographer/tests/deinterleaver_test.cc

   1 #include "utils.h"
   2 #include "audiographer/deinterleaver.h"
   3
   4 using namespace AudioGrapher;
   5
   6 class DeInterleaverTest : public CppUnit::TestFixture
   7 {
   8   CPPUNIT_TEST_SUITE (DeInterleaverTest);
   9   CPPUNIT_TEST (testUninitialized);
  10   CPPUNIT_TEST (testInvalidOutputIndex);
  11   CPPUNIT_TEST (testInvalidInputSize);
  12   CPPUNIT_TEST (testOutputSize);
  13   CPPUNIT_TEST (testZeroInput);
  14   CPPUNIT_TEST_SUITE_END ();
  15
  16   public:
  17         void setUp()
  18         {
  19                 channels = 3;
  20                 frames_per_channel = 128;
  21                 total_frames = channels * frames_per_channel;
  22                 random_data = TestUtils::init_random_data (total_frames, 1.0);
  23
  24                 deinterleaver.reset (new DeInterleaver<float>());
  25                 sink_a.reset (new VectorSink<float>());
  26                 sink_b.reset (new VectorSink<float>());
  27                 sink_c.reset (new VectorSink<float>());
  28         }
  29
  30         void tearDown()
  31         {
  32                 delete [] random_data;
  33         }
  34
  35         void testUninitialized()
  36         {
  37                 deinterleaver.reset (new DeInterleaver<float>());
  38                 CPPUNIT_ASSERT_THROW (deinterleaver->output(0)->add_output (sink_a), Exception);
  39         }
  40
  41         void testInvalidOutputIndex()
  42         {
  43                 deinterleaver->init (3, frames_per_channel);
  44                 CPPUNIT_ASSERT_THROW (deinterleaver->output(3)->add_output (sink_a), Exception);
  45         }
  46
  47         void testInvalidInputSize()
  48         {
  49                 deinterleaver->init (channels, frames_per_channel);
  50
  51                 ProcessContext<float> c (random_data, 0, channels);
  52
  53                 // Too many, frames % channels == 0
  54                 c.frames() = total_frames + channels;
  55                 CPPUNIT_ASSERT_THROW (deinterleaver->process (c), Exception);
  56
  57                 // Too many, frames % channels != 0
  58                 c.frames() =  total_frames + 1;
  59                 CPPUNIT_ASSERT_THROW (deinterleaver->process (c), Exception);
  60
  61                 // Too few, frames % channels != 0
  62                 c.frames() =  total_frames - 1;
  63                 CPPUNIT_ASSERT_THROW (deinterleaver->process (c), Exception);
  64         }
  65
  66         void assert_outputs (nframes_t expected_frames)
  67         {
  68                 nframes_t generated_frames = 0;
  69
  70                 generated_frames = sink_a->get_data().size();
  71                 CPPUNIT_ASSERT_EQUAL (expected_frames, generated_frames);
  72
  73                 generated_frames = sink_b->get_data().size();
  74                 CPPUNIT_ASSERT_EQUAL (expected_frames, generated_frames);
  75
  76                 generated_frames = sink_c->get_data().size();
  77                 CPPUNIT_ASSERT_EQUAL (expected_frames, generated_frames);
  78         }
  79
  80         void testOutputSize()
  81         {
  82                 deinterleaver->init (channels, frames_per_channel);
  83
  84                 deinterleaver->output (0)->add_output (sink_a);
  85                 deinterleaver->output (1)->add_output (sink_b);
  86                 deinterleaver->output (2)->add_output (sink_c);
  87
  88                 // Test maximum frame input
  89                 ProcessContext<float> c (random_data, total_frames, channels);
  90                 deinterleaver->process (c);
  91                 assert_outputs (frames_per_channel);
  92
  93                 // Now with less frames
  94                 nframes_t const less_frames = frames_per_channel / 4;
  95                 c.frames() = less_frames * channels;
  96                 deinterleaver->process (c);
  97                 assert_outputs (less_frames);
  98         }
  99
 100         void testZeroInput()
 101         {
 102                 deinterleaver->init (channels, frames_per_channel);
 103
 104                 deinterleaver->output (0)->add_output (sink_a);
 105                 deinterleaver->output (1)->add_output (sink_b);
 106                 deinterleaver->output (2)->add_output (sink_c);
 107
 108                 // Input zero frames
 109                 ProcessContext<float> c (random_data, 0, channels);
 110                 deinterleaver->process (c);
 111
 112                 // ...and now test regular input
 113                 c.frames() = total_frames;
 114                 deinterleaver->process (c);
 115                 assert_outputs (frames_per_channel);
 116         }
 117
 118
 119   private:
 120         boost::shared_ptr<DeInterleaver<float> > deinterleaver;
 121
 122         boost::shared_ptr<VectorSink<float> > sink_a;
 123         boost::shared_ptr<VectorSink<float> > sink_b;
 124         boost::shared_ptr<VectorSink<float> > sink_c;
 125
 126         float * random_data;
 127         nframes_t frames_per_channel;
 128         nframes_t total_frames;
 129         unsigned int channels;
 130 };
 131
 132 CPPUNIT_TEST_SUITE_REGISTRATION (DeInterleaverTest);
 133