Conversational Speech tool completed

webrtc/modules/audio_processing/test/conversational_speech/generator_unittest.cc

 /*
  *  Copyright (c) 2017 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 // This file consists of unit tests for webrtc::test::conversational_speech
 // members. Part of them focus on accepting or rejecting different
 // conversational speech setups. A setup is defined by a set of audio tracks and
 // timing information).
-// The docstring at the beginning of each TEST_F(ConversationalSpeechTest,
+// The docstring at the beginning of each TEST(ConversationalSpeechTest,
 // MultiEndCallSetup*) function looks like the drawing below and indicates which
 // setup is tested.
 //
 //    Accept:
 //    A 0****.....
 //    B .....1****
 //
 // The drawing indicates the following:
 // - the illustrated setup should be accepted,
 // - there are two speakers (namely, A and B),
@@ skipping 123 matching lines @@
   auto wav_reader = wav_reader_factory.Create(filepath);
   EXPECT_EQ(expeted_params.sample_rate, wav_reader->SampleRate());
   EXPECT_EQ(expeted_params.num_channels, wav_reader->NumChannels());
   EXPECT_EQ(expeted_params.num_samples, wav_reader->NumSamples());
 }
 
 }  // namespace
 
 using testing::_;
 
-// TODO(alessiob): Remove fixture once conversational_speech fully implemented
-// and replace TEST_F with TEST.
-class ConversationalSpeechTest : public testing::Test {
- public:
-  ConversationalSpeechTest() {
-    rtc::LogMessage::LogToDebug(rtc::LS_VERBOSE);
-  }
-};
-
-TEST_F(ConversationalSpeechTest, Settings) {
+TEST(ConversationalSpeechTest, Settings) {
   const conversational_speech::Config config(
       audiotracks_path, timing_filepath, output_path);
 
   // Test getters.
   EXPECT_EQ(audiotracks_path, config.audiotracks_path());
   EXPECT_EQ(timing_filepath, config.timing_filepath());
   EXPECT_EQ(output_path, config.output_path());
 }
 
-TEST_F(ConversationalSpeechTest, TimingSaveLoad) {
+TEST(ConversationalSpeechTest, TimingSaveLoad) {
   // Save test timing.
   const std::string temporary_filepath = webrtc::test::TempFilename(
       webrtc::test::OutputPath(), "TempTimingTestFile");
   SaveTiming(temporary_filepath, expected_timing);
 
   // Create a std::vector<Turn> instance by loading from file.
   std::vector<Turn> actual_timing = LoadTiming(temporary_filepath);
   std::remove(temporary_filepath.c_str());
 
   // Check size.
   EXPECT_EQ(expected_timing.size(), actual_timing.size());
 
   // Check Turn instances.
   for (size_t index = 0; index < expected_timing.size(); ++index) {
     EXPECT_EQ(expected_timing[index], actual_timing[index])
         << "turn #" << index << " not matching";
   }
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallCreate) {
+TEST(ConversationalSpeechTest, MultiEndCallCreate) {
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are 5 unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(5);
 
   // Inject the mock wav reader factory.
   conversational_speech::MultiEndCall multiend_call(
       expected_timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(5u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(6u, multiend_call.speaking_turns().size());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupDifferentSampleRates) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupDifferentSampleRates) {
   const std::vector<Turn> timing = {
       {"A", "sr8000", 0},
       {"B", "sr16000", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(testing::_)).Times(2);
 
   MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupMultipleChannels) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupMultipleChannels) {
   const std::vector<Turn> timing = {
       {"A", "sr16000_stereo", 0},
       {"B", "sr16000_stereo", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(testing::_)).Times(1);
 
   MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest,
+TEST(ConversationalSpeechTest,
        MultiEndCallSetupDifferentSampleRatesAndMultipleNumChannels) {
   const std::vector<Turn> timing = {
       {"A", "sr8000", 0},
       {"B", "sr16000_stereo", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(testing::_)).Times(2);
 
   MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupFirstOffsetNegative) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupFirstOffsetNegative) {
   const std::vector<Turn> timing = {
       {"A", "t500", -100},
       {"B", "t500", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupSimple) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupSimple) {
   // Accept:
   // A 0****.....
   // B .....1****
   constexpr std::size_t expected_duration = kDefaultSampleRate;
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(1u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(2u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupPause) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupPause) {
   // Accept:
   // A 0****.......
   // B .......1****
   constexpr std::size_t expected_duration = kDefaultSampleRate * 1.2;
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", 200},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(1u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(2u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalk) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalk) {
   // Accept:
   // A 0****....
   // B ....1****
   constexpr std::size_t expected_duration = kDefaultSampleRate * 0.9;
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", -100},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(1u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(2u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupInvalidOrder) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupInvalidOrder) {
   // Reject:
   // A ..0****
   // B .1****.  The n-th turn cannot start before the (n-1)-th one.
   const std::vector<Turn> timing = {
       {"A", "t500", 200},
       {"B", "t500", -600},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalkThree) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalkThree) {
   // Accept:
   // A 0****2****...
   // B ...1*********
   constexpr std::size_t expected_duration = kDefaultSampleRate * 1.3;
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t1000", -200},
       {"A", "t500", -800},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(2u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(3u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupSelfCrossTalkNearInvalid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupSelfCrossTalkNearInvalid) {
   // Reject:
   // A 0****......
   // A ...1****...
   // B ......2****
   //      ^  Turn #1 overlaps with #0 which is from the same speaker.
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"A", "t500", -200},
       {"B", "t500", -200},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupSelfCrossTalkFarInvalid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupSelfCrossTalkFarInvalid) {
   // Reject:
   // A 0*********
   // B 1**.......
   // C ...2**....
   // A ......3**.
   //         ^  Turn #3 overlaps with #0 which is from the same speaker.
   const std::vector<Turn> timing = {
       {"A", "t1000", 0},
       {"B", "t300", -1000},
       {"C", "t300", 0},
       {"A", "t300", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleValid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleValid) {
   // Accept:
   // A 0*********..
   // B ..1****.....
   // C .......2****
   constexpr std::size_t expected_duration = kDefaultSampleRate * 1.2;
   const std::vector<Turn> timing = {
       {"A", "t1000", 0},
       {"B", "t500", -800},
       {"C", "t500", 0},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(3u, multiend_call.speaker_names().size());
   EXPECT_EQ(2u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(3u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleInvalid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleInvalid) {
   // Reject:
   // A 0*********
   // B ..1****...
   // C ....2****.
   //       ^  Turn #2 overlaps both with #0 and #1 (cross-talk with 3+ speakers
   //          not permitted).
   const std::vector<Turn> timing = {
       {"A", "t1000", 0},
       {"B", "t500", -800},
       {"C", "t500", -300},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleAndPause) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalkMiddleAndPause) {
   // Accept:
   // A 0*********..
   // B .2****......
   // C .......3****
   constexpr std::size_t expected_duration = kDefaultSampleRate * 1.2;
   const std::vector<Turn> timing = {
       {"A", "t1000", 0},
       {"B", "t500", -900},
       {"C", "t500", 100},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(3u, multiend_call.speaker_names().size());
   EXPECT_EQ(2u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(3u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupCrossTalkFullOverlapValid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupCrossTalkFullOverlapValid) {
   // Accept:
   // A 0****
   // B 1****
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", -500},
   };
   auto mock_wavreader_factory = CreateMockWavReaderFactory();
 
   // There is one unique audio track to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(1);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(2u, multiend_call.speaker_names().size());
   EXPECT_EQ(1u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(2u, multiend_call.speaking_turns().size());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupLongSequence) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupLongSequence) {
   // Accept:
   // A 0****....3****.5**.
   // B .....1****...4**...
   // C ......2**.......6**..
   constexpr std::size_t expected_duration = kDefaultSampleRate * 1.9;
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", 0},
       {"C", "t300", -400},
       {"A", "t500", 0},
@@ skipping 12 matching lines @@
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_TRUE(multiend_call.valid());
 
   // Test.
   EXPECT_EQ(3u, multiend_call.speaker_names().size());
   EXPECT_EQ(2u, multiend_call.audiotrack_readers().size());
   EXPECT_EQ(7u, multiend_call.speaking_turns().size());
   EXPECT_EQ(expected_duration, multiend_call.total_duration_samples());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSetupLongSequenceInvalid) {
+TEST(ConversationalSpeechTest, MultiEndCallSetupLongSequenceInvalid) {
   // Reject:
   // A 0****....3****.6**
   // B .....1****...4**..
   // C ......2**.....5**..
   //                 ^ Turns #4, #5 and #6 overlapping (cross-talk with 3+
   //                   speakers not permitted).
   const std::vector<Turn> timing = {
       {"A", "t500", 0},
       {"B", "t500", 0},
       {"C", "t300", -400},
       {"A", "t500", 0},
       {"B", "t300", -100},
       {"A", "t300", -200},
       {"C", "t300", -200},
   };
   auto mock_wavreader_factory = std::unique_ptr<MockWavReaderFactory>(
       new MockWavReaderFactory(kDefaultMockWavReaderFactoryParams,
                                kDefaultMockWavReaderFactoryParamsMap));
 
   // There are two unique audio tracks to read.
   EXPECT_CALL(*mock_wavreader_factory, Create(_)).Times(2);
 
   conversational_speech::MultiEndCall multiend_call(
       timing, audiotracks_path, std::move(mock_wavreader_factory));
   EXPECT_FALSE(multiend_call.valid());
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallWavReaderAdaptorSine) {
+TEST(ConversationalSpeechTest, MultiEndCallWavReaderAdaptorSine) {
   // Parameters with which wav files are created.
   constexpr int duration_seconds = 5;
   const int sample_rates[] = {8000, 11025, 16000, 22050, 32000, 44100, 48000};
 
   for (int sample_rate : sample_rates) {
     const rtc::Pathname temp_filename(
         OutputPath(), "TempSineWavFile_" + std::to_string(sample_rate)
             + ".wav");
 
     // Write wav file.
     const std::size_t num_samples = duration_seconds * sample_rate;
     MockWavReaderFactory::Params params = {sample_rate, 1u, num_samples};
     CreateSineWavFile(temp_filename.pathname(), params);
 
     // Load wav file and check if params match.
     WavReaderFactory wav_reader_factory;
     MockWavReaderFactory::Params expeted_params = {
         sample_rate, 1u, num_samples};
     CheckAudioTrackParams(
         wav_reader_factory, temp_filename.pathname(), expeted_params);
 
     // Clean up.
     remove(temp_filename.pathname().c_str());
   }
 }
 
-TEST_F(ConversationalSpeechTest, MultiEndCallSimulator) {
+TEST(ConversationalSpeechTest, MultiEndCallSimulator) {
   // Simulated call (one character corresponding to 500 ms):
   // A 0*********...........2*********.....
   // B ...........1*********.....3*********
   const std::vector<Turn> expected_timing = {
       {"A", "t5000_440.wav", 0},
       {"B", "t5000_880.wav", 500},
       {"A", "t5000_440.wav", 0},
       {"B", "t5000_880.wav", -2500},
   };
   const std::size_t expected_duration_seconds = 18;
@@ skipping 36 matching lines @@
   }
 
   // Clean.
   EXPECT_TRUE(rtc::Filesystem::DeleteFolderAndContents(
     rtc::Pathname(audiotracks_path)))
         << "Cannot delete temporary data directory " << audiotracks_path;
 }
 
 }  // namespace test
 }  // namespace webrtc