media/mojo/mojom/speech_recognition_result_mojom_traits_unittest.cc

   1 // Copyright 2021 The Chromium Authors
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/mojo/mojom/speech_recognition_result_mojom_traits.h"
   6
   7 #include <vector>
   8
   9 #include "base/time/time.h"
  10 #include "media/mojo/mojom/speech_recognition_result.h"
  11 #include "testing/gtest/include/gtest/gtest.h"
  12
  13 namespace media {
  14
  15 namespace {
  16
  17 base::TimeDelta kZeroTime = base::Seconds(0);
  18 }
  19
  20 TEST(SpeechRecognitionResultStructTraitsTest, NoTimingInformation) {
  21   media::SpeechRecognitionResult result("hello world", true);
  22   std::vector<uint8_t> data =
  23       media::mojom::SpeechRecognitionResult::Serialize(&result);
  24   media::SpeechRecognitionResult output;
  25   EXPECT_TRUE(media::mojom::SpeechRecognitionResult::Deserialize(
  26       std::move(data), &output));
  27   EXPECT_EQ(result, output);
  28 }
  29
  30 TEST(SpeechRecognitionResultStructTraitsTest, WithTimingInformation) {
  31   media::SpeechRecognitionResult invalid_result("hello world", true);
  32   invalid_result.timing_information = media::TimingInformation();
  33   invalid_result.timing_information->audio_start_time = kZeroTime;
  34   invalid_result.timing_information->audio_end_time = base::Seconds(-1);
  35   std::vector<uint8_t> data =
  36       media::mojom::SpeechRecognitionResult::Serialize(&invalid_result);
  37   media::SpeechRecognitionResult output;
  38   EXPECT_FALSE(media::mojom::SpeechRecognitionResult::Deserialize(
  39       std::move(data), &output));
  40
  41   media::SpeechRecognitionResult valid_result("hello world", true);
  42   valid_result.timing_information = media::TimingInformation();
  43   valid_result.timing_information->audio_start_time = kZeroTime;
  44   valid_result.timing_information->audio_end_time = base::Seconds(1);
  45   std::vector<uint8_t> valid_data =
  46       media::mojom::SpeechRecognitionResult::Serialize(&valid_result);
  47   media::SpeechRecognitionResult valid_output;
  48   EXPECT_TRUE(media::mojom::SpeechRecognitionResult::Deserialize(
  49       std::move(valid_data), &valid_output));
  50   EXPECT_EQ(valid_result, valid_output);
  51 }
  52
  53 TEST(SpeechRecognitionResultStructTraitsTest,
  54      PartialResultWithTimingInformation) {
  55   media::SpeechRecognitionResult invalid_result("hello world", false);
  56   invalid_result.timing_information = media::TimingInformation();
  57   invalid_result.timing_information->audio_start_time = kZeroTime;
  58   invalid_result.timing_information->audio_end_time = base::Seconds(1);
  59   std::vector<uint8_t> invalid_data =
  60       media::mojom::SpeechRecognitionResult::Serialize(&invalid_result);
  61   media::SpeechRecognitionResult invalid_output;
  62
  63   // Partial results shouldn't have timing information.
  64   EXPECT_FALSE(media::mojom::SpeechRecognitionResult::Deserialize(
  65       std::move(invalid_data), &invalid_output));
  66 }
  67
  68 TEST(SpeechRecognitionResultStructTraitsTest, WithInvalidHypothesisParts) {
  69   media::SpeechRecognitionResult invalid_result("hello world", true);
  70   invalid_result.timing_information = media::TimingInformation();
  71   invalid_result.timing_information->audio_start_time = kZeroTime;
  72   invalid_result.timing_information->audio_end_time = base::Seconds(1);
  73   invalid_result.timing_information->hypothesis_parts =
  74       std::vector<media::HypothesisParts>();
  75   auto& hypothesis_parts =
  76       invalid_result.timing_information->hypothesis_parts.value();
  77   // Invalid hypothesis parts (outside the range audio_start_time to
  78   // audio_end_time):
  79   hypothesis_parts.emplace_back(std::vector<std::string>({"hello"}),
  80                                 base::Seconds(-1));
  81   hypothesis_parts.emplace_back(std::vector<std::string>({"world"}),
  82                                 base::Seconds(2));
  83   std::vector<uint8_t> data =
  84       media::mojom::SpeechRecognitionResult::Serialize(&invalid_result);
  85   media::SpeechRecognitionResult output;
  86   EXPECT_FALSE(media::mojom::SpeechRecognitionResult::Deserialize(
  87       std::move(data), &output));
  88 }
  89
  90 TEST(SpeechRecognitionResultStructTraitsTest, WithValidHypothesisParts) {
  91   media::SpeechRecognitionResult valid_result("hello world", true);
  92   valid_result.timing_information = media::TimingInformation();
  93   valid_result.timing_information->audio_start_time = kZeroTime;
  94   valid_result.timing_information->audio_end_time = base::Seconds(1);
  95   valid_result.timing_information->hypothesis_parts =
  96       std::vector<media::HypothesisParts>();
  97   auto& hypothesis_parts =
  98       valid_result.timing_information->hypothesis_parts.value();
  99   hypothesis_parts.emplace_back(std::vector<std::string>({"hello"}),
 100                                 base::Seconds(0));
 101   hypothesis_parts.emplace_back(std::vector<std::string>({"world"}),
 102                                 base::Seconds(1));
 103   std::vector<uint8_t> data =
 104       media::mojom::SpeechRecognitionResult::Serialize(&valid_result);
 105   media::SpeechRecognitionResult output;
 106   EXPECT_TRUE(media::mojom::SpeechRecognitionResult::Deserialize(
 107       std::move(data), &output));
 108   EXPECT_EQ(valid_result, output);
 109 }
 110
 111 }  // namespace media