libs/audiographer/tests/general/silence_trimmer_test.cc

   1 #include "tests/utils.h"
   2
   3 #include "audiographer/general/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                 samples = 128;
  21
  22                 random_data = TestUtils::init_random_data(samples);
  23                 random_data[0] = 0.5;
  24                 random_data[samples - 1] = 0.5;
  25
  26                 zero_data = new float[samples];
  27                 memset(zero_data, 0, samples * sizeof(float));
  28
  29                 half_random_data = TestUtils::init_random_data(samples);
  30                 memset(half_random_data, 0, (samples / 2) * sizeof(float));
  31
  32                 trimmer.reset (new SilenceTrimmer<float> (samples / 2));
  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
  46         void testFullBuffers()
  47         {
  48                 trimmer->add_output (sink);
  49
  50                 {
  51                 ProcessContext<float> c (zero_data, samples, 1);
  52                 trimmer->process (c);
  53                 samplecnt_t samples_processed = sink->get_data().size();
  54                 CPPUNIT_ASSERT_EQUAL ((samplecnt_t) 0, samples_processed);
  55                 }
  56
  57                 {
  58                 ProcessContext<float> c (random_data, samples, 1);
  59                 trimmer->process (c);
  60                 samplecnt_t samples_processed = sink->get_data().size();
  61                 CPPUNIT_ASSERT_EQUAL (samples, samples_processed);
  62                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, samples));
  63                 }
  64
  65                 {
  66                 ProcessContext<float> c (zero_data, samples, 1);
  67                 trimmer->process (c);
  68                 samplecnt_t samples_processed = sink->get_data().size();
  69                 CPPUNIT_ASSERT_EQUAL (samples, samples_processed);
  70                 }
  71
  72                 {
  73                 ProcessContext<float> c (random_data, samples, 1);
  74                 trimmer->process (c);
  75                 samplecnt_t samples_processed = sink->get_data().size();
  76                 CPPUNIT_ASSERT_EQUAL (3 * samples, samples_processed);
  77                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, samples));
  78                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[samples], zero_data, samples));
  79                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[2 * samples], random_data, samples));
  80                 }
  81
  82                 {
  83                 ProcessContext<float> c (zero_data, samples, 1);
  84                 trimmer->process (c);
  85                 samplecnt_t samples_processed = sink->get_data().size();
  86                 CPPUNIT_ASSERT_EQUAL (3 * samples, samples_processed);
  87                 }
  88         }
  89
  90         void testPartialBuffers()
  91         {
  92                 trimmer->add_output (sink);
  93                 trimmer->reset (samples / 4);
  94                 trimmer->set_trim_beginning (true);
  95                 trimmer->set_trim_end (true);
  96
  97                 {
  98                 ProcessContext<float> c (half_random_data, samples, 1);
  99                 trimmer->process (c);
 100                 samplecnt_t samples_processed = sink->get_data().size();
 101                 CPPUNIT_ASSERT_EQUAL (samples / 2, samples_processed);
 102                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), &half_random_data[samples / 2], samples / 2));
 103                 }
 104
 105                 {
 106                 ProcessContext<float> c (zero_data, samples, 1);
 107                 trimmer->process (c);
 108                 samplecnt_t samples_processed = sink->get_data().size();
 109                 CPPUNIT_ASSERT_EQUAL (samples / 2, samples_processed);
 110                 }
 111
 112                 {
 113                 ProcessContext<float> c (half_random_data, samples, 1);
 114                 trimmer->process (c);
 115                 samplecnt_t samples_processed = sink->get_data().size();
 116                 CPPUNIT_ASSERT_EQUAL (2 * samples + samples / 2, samples_processed);
 117                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[samples + samples / 2], half_random_data, samples));
 118                 }
 119         }
 120
 121         void testExceptions()
 122         {
 123                 {
 124                 CPPUNIT_ASSERT_THROW (trimmer->reset (0), Exception);
 125                 }
 126         }
 127
 128         void testAddSilenceBeginning()
 129         {
 130                 trimmer->add_output (sink);
 131
 132                 samplecnt_t silence = samples / 2;
 133                 trimmer->add_silence_to_beginning (silence);
 134
 135                 {
 136                 ProcessContext<float> c (random_data, samples, 1);
 137                 trimmer->process (c);
 138                 }
 139
 140                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), zero_data, silence));
 141                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[silence], random_data, samples));
 142         }
 143
 144         void testAddSilenceEnd()
 145         {
 146                 trimmer->add_output (sink);
 147
 148                 samplecnt_t silence = samples / 3;
 149                 trimmer->add_silence_to_end (silence);
 150
 151                 {
 152                 ProcessContext<float> c (random_data, samples, 1);
 153                 trimmer->process (c);
 154                 }
 155
 156                 {
 157                 ProcessContext<float> c (random_data, samples, 1);
 158                 c.set_flag (ProcessContext<float>::EndOfInput);
 159                 trimmer->process (c);
 160                 }
 161
 162                 samplecnt_t samples_processed = sink->get_data().size();
 163                 samplecnt_t total_samples = 2 * samples + silence;
 164                 CPPUNIT_ASSERT_EQUAL (total_samples, samples_processed);
 165                 CPPUNIT_ASSERT (TestUtils::array_equals (sink->get_array(), random_data, samples));
 166                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[samples], random_data, samples));
 167                 CPPUNIT_ASSERT (TestUtils::array_equals (&sink->get_array()[samples * 2], zero_data, silence));
 168         }
 169
 170   private:
 171         boost::shared_ptr<SilenceTrimmer<float> > trimmer;
 172         boost::shared_ptr<AppendingVectorSink<float> > sink;
 173
 174         float * random_data;
 175         float * zero_data;
 176         float * half_random_data;
 177         samplecnt_t samples;
 178 };
 179
 180 CPPUNIT_TEST_SUITE_REGISTRATION (SilenceTrimmerTest);