libs/audiographer/tests/silence_trimmer_test.cc

   1 #include "utils.h"
   2
   3 #include "audiographer/silence_trimmer.h"
   4
   5 using namespace AudioGrapher;
   6
   7 class SilenceTrimmerTest : public CppUnit::TestFixture
   8 {
   9   CPPUNIT_TEST_SUITE (SilenceTrimmerTest);
  10   CPPUNIT_TEST (testExceptions);
  11   CPPUNIT_TEST (testFullBuffers);
  12   CPPUNIT_TEST (testPartialBuffers);
  13   CPPUNIT_TEST (testAddSilenceBeginning);
  14   CPPUNIT_TEST (testAddSilenceEnd);
  15   CPPUNIT_TEST_SUITE_END ();
  16
  17   public:
  18         void setUp()
  19         {
  20                 frames = 128;
  21
  22                 random_data = TestUtils::init_random_data(frames);
  23                 random_data[0] = 0.5;
  24                 random_data[frames - 1] = 0.5;
  25
  26                 zero_data = new float[frames];
  27                 memset(zero_data, 0, frames * sizeof(float));
  28
  29                 half_random_data = TestUtils::init_random_data(frames);
  30                 memset(half_random_data, 0, (frames / 2) * sizeof(float));
  31
  32                 trimmer.reset (new SilenceTrimmer<float>());
  33                 sink.reset (new AppendingVectorSink<float>());
  34
  35                 trimmer->set_trim_beginning (true);
  36                 trimmer->set_trim_end (true);
  37         }
  38
  39         void tearDown()
  40         {
  41                 delete [] random_data;
  42                 delete [] zero_data;
  43                 delete [] half_random_data;
  44
  45                 AudioGrapher::Utils::free_resources();
  46         }
  47
  48         void testFullBuffers()
  49         {
  50                 trimmer->add_output (sink);
  51                 AudioGrapher::Utils::init_zeros<float>(frames / 2);
  52
  53                 {
  54                 ProcessContext<float> c (zero_data, frames, 1);
  55                 trimmer->process (c);
  56                 nframes_t frames_processed = sink->get_data().size();
  57                 CPPUNIT_ASSERT_EQUAL ((nframes_t) 0, frames_processed);
  58                 }
  59
  60                 {
  61                 ProcessContext<float> c (random_data, frames, 1);
  62                 trimmer->process (c);
  63                 nframes_t frames_processed = sink->get_data().size();
  64                 CPPUNIT_ASSERT_EQUAL (frames, frames_processed);
  65                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
  66                 }
  67
  68                 {
  69                 ProcessContext<float> c (zero_data, frames, 1);
  70                 trimmer->process (c);
  71                 nframes_t frames_processed = sink->get_data().size();
  72                 CPPUNIT_ASSERT_EQUAL (frames, frames_processed);
  73                 }
  74
  75                 {
  76                 ProcessContext<float> c (random_data, frames, 1);
  77                 trimmer->process (c);
  78                 nframes_t frames_processed = sink->get_data().size();
  79                 CPPUNIT_ASSERT_EQUAL (3 * frames, frames_processed);
  80                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
  81                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames], zero_data, frames));
  82                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[2 * frames], random_data, frames));
  83                 }
  84
  85                 {
  86                 ProcessContext<float> c (zero_data, frames, 1);
  87                 trimmer->process (c);
  88                 nframes_t frames_processed = sink->get_data().size();
  89                 CPPUNIT_ASSERT_EQUAL (3 * frames, frames_processed);
  90                 }
  91         }
  92
  93         void testPartialBuffers()
  94         {
  95                 trimmer->add_output (sink);
  96                 AudioGrapher::Utils::init_zeros<float>(frames / 4);
  97
  98                 {
  99                 ProcessContext<float> c (half_random_data, frames, 1);
 100                 trimmer->process (c);
 101                 nframes_t frames_processed = sink->get_data().size();
 102                 CPPUNIT_ASSERT_EQUAL (frames / 2, frames_processed);
 103                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), &half_random_data[frames / 2], frames / 2));
 104                 }
 105
 106                 {
 107                 ProcessContext<float> c (zero_data, frames, 1);
 108                 trimmer->process (c);
 109                 nframes_t frames_processed = sink->get_data().size();
 110                 CPPUNIT_ASSERT_EQUAL (frames / 2, frames_processed);
 111                 }
 112
 113                 {
 114                 ProcessContext<float> c (half_random_data, frames, 1);
 115                 trimmer->process (c);
 116                 nframes_t frames_processed = sink->get_data().size();
 117                 CPPUNIT_ASSERT_EQUAL (2 * frames + frames / 2, frames_processed);
 118                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames + frames / 2], half_random_data, frames));
 119                 }
 120         }
 121
 122         void testExceptions()
 123         {
 124                 // TODO more tests here
 125
 126                 trimmer->add_output (sink);
 127
 128                 {
 129                 ProcessContext<float> c (random_data, frames, 1);
 130                 trimmer->process (c);
 131                 }
 132
 133                 {
 134                 ProcessContext<float> c (zero_data, frames, 1);
 135                 trimmer->process (c);
 136                 }
 137
 138                 {
 139                 // Zeros not inited, so this should throw
 140                 ProcessContext<float> c (random_data, frames, 1);
 141                 CPPUNIT_ASSERT_THROW (trimmer->process (c), Exception);
 142                 }
 143         }
 144
 145         void testAddSilenceBeginning()
 146         {
 147                 trimmer->add_output (sink);
 148                 AudioGrapher::Utils::init_zeros<float>(frames / 2);
 149
 150                 nframes_t silence = frames / 2;
 151                 trimmer->add_silence_to_beginning (silence);
 152
 153                 {
 154                 ProcessContext<float> c (random_data, frames, 1);
 155                 trimmer->process (c);
 156                 }
 157
 158                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), zero_data, silence));
 159                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[silence], random_data, frames));
 160         }
 161
 162         void testAddSilenceEnd()
 163         {
 164                 trimmer->add_output (sink);
 165                 AudioGrapher::Utils::init_zeros<float>(frames / 2);
 166
 167                 nframes_t silence = frames / 3;
 168                 trimmer->add_silence_to_end (silence);
 169
 170                 {
 171                 ProcessContext<float> c (random_data, frames, 1);
 172                 trimmer->process (c);
 173                 }
 174
 175                 {
 176                 ProcessContext<float> c (random_data, frames, 1);
 177                 c.set_flag (ProcessContext<float>::EndOfInput);
 178                 trimmer->process (c);
 179                 }
 180
 181                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, frames));
 182                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames], random_data, frames));
 183                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[frames * 2], zero_data, silence));
 184         }
 185
 186   private:
 187         boost::shared_ptr<SilenceTrimmer<float> > trimmer;
 188         boost::shared_ptr<AppendingVectorSink<float> > sink;
 189
 190         float * random_data;
 191         float * zero_data;
 192         float * half_random_data;
 193         nframes_t frames;
 194 };
 195
 196 CPPUNIT_TEST_SUITE_REGISTRATION (SilenceTrimmerTest);