// Copyright 2018 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/cobalt/bin/testapp/tests.h"

#include <fuchsia/diagnostics/cpp/fidl.h>
#include <lib/sys/cpp/service_directory.h>

#include <ctime>

#include <rapidjson/document.h>
#include <rapidjson/pointer.h>

#include "src/cobalt/bin/testapp/internal_metrics_registry.cb.h"
#include "src/cobalt/bin/testapp/prober_metrics_registry.cb.h"
#include "src/cobalt/bin/testapp/test_constants.h"
#include "src/cobalt/bin/testapp/testapp_metrics_registry.cb.h"
#include "src/cobalt/bin/utils/base64.h"
#include "third_party/cobalt/src/lib/util/datetime_util.h"

namespace cobalt::testapp {

using fidl::VectorPtr;
using fuchsia::cobalt::Status;
using util::SystemClockInterface;
using util::TimeToDayIndex;
using LoggerMethod = cobalt_internal_registry::LoggerCallsMadeMigratedMetricDimensionLoggerMethod;

namespace {
uint32_t CurrentDayIndex(SystemClockInterface* clock) {
  return TimeToDayIndex(std::chrono::system_clock::to_time_t(clock->now()), MetricDefinition::UTC);
}

bool SendAndCheckSuccess(const std::string& test_name, CobaltTestAppLogger* logger) {
  if (!logger->CheckForSuccessfulSend()) {
    FX_LOGS(INFO) << "CheckForSuccessfulSend() returned false";
    FX_LOGS(INFO) << test_name << ": FAIL";
    return false;
  }
  FX_LOGS(INFO) << test_name << ": PASS";
  return true;
}
}  // namespace

////////////////////// Tests using local aggregation ///////////////////////

// A helper function which generates locally aggregated observations for
// |day_index| and checks that the number of generated observations is equal to
// the expected number for each locally aggregated report ID. The keys of
// |expected_num_obs| should be the elements of |kAggregatedReportIds|.
bool GenerateObsAndCheckCount(uint32_t day_index,
                              fuchsia::cobalt::ControllerSyncPtr* cobalt_controller,
                              uint32_t project_id,
                              std::map<std::pair<uint32_t, uint32_t>, uint64_t> expected_num_obs) {
  FX_LOGS(INFO) << "Generating locally aggregated observations for day index " << day_index;
  std::vector<fuchsia::cobalt::ReportSpec> aggregatedReportSpecs;
  std::vector<std::pair<uint32_t, uint32_t>> aggregatedReportIds;
  for (const auto& [ids, expected] : expected_num_obs) {
    const auto& [metric_id, report_id] = ids;
    fuchsia::cobalt::ReportSpec report_spec = std::move(fuchsia::cobalt::ReportSpec()
                                                            .set_customer_id(1)
                                                            .set_project_id(project_id)
                                                            .set_metric_id(metric_id)
                                                            .set_report_id(report_id));
    aggregatedReportSpecs.push_back(std::move(report_spec));
    aggregatedReportIds.push_back(ids);
  }
  std::vector<uint64_t> num_obs;
  (*cobalt_controller)
      ->GenerateAggregatedObservations(day_index, std::move(aggregatedReportSpecs), &num_obs);
  for (size_t i = 0; i < aggregatedReportIds.size(); i++) {
    const auto& [metric_id, report_id] = aggregatedReportIds[i];
    uint64_t expected = expected_num_obs[{metric_id, report_id}];
    uint64_t found = num_obs[i];
    if (found != expected) {
      FX_LOGS(INFO) << "Expected " << expected << " observations for report MetricID " << metric_id
                    << " ReportId " << report_id << ", found " << found;
      return false;
    }
  }
  return true;
}

bool CheckInspectData(CobaltTestAppLogger* logger, uint32_t project_id, LoggerMethod method,
                      int64_t expected_logger_calls,
                      const std::map<std::pair<uint32_t, uint32_t>, uint64_t>& expected_num_obs) {
  std::string inspect_json = logger->GetInspectJson();
  rapidjson::Document inspect;
  inspect.Parse(inspect_json);

  rapidjson::Pointer pointer(
      "/payload/root/cobalt_app/core/internal_metrics/logger_calls/per_method/method_" +
      std::to_string(method) + "/num_calls");
  rapidjson::Value& value = rapidjson::GetValueByPointerWithDefault(inspect, pointer, -1);
  if (value.GetInt64() != expected_logger_calls) {
    FX_LOGS(ERROR) << "Expected " << expected_logger_calls << " logger calls to method " << method
                   << ", found "
                   << (value.GetInt64() == -1 ? "none" : std::to_string(value.GetInt64()))
                   << "\nFull inspect data: " << inspect_json;
    return false;
  }

  pointer = rapidjson::Pointer(
      std::string(
          "/payload/root/cobalt_app/core/internal_metrics/logger_calls/per_project/fuchsia~1") +
      (project_id == cobalt_registry::kProjectId ? cobalt_registry::kProjectName
                                                 : cobalt_prober_registry::kProjectName) +
      "/num_calls");
  value = rapidjson::GetValueByPointerWithDefault(inspect, pointer, -1);
  if (value.GetInt64() != expected_logger_calls) {
    FX_LOGS(ERROR) << "Expected " << expected_logger_calls << " logger calls for project "
                   << project_id << ", found "
                   << (value.GetInt64() == -1 ? "none" : std::to_string(value.GetInt64()))
                   << "\nFull inspect data: " << inspect_json;
    return false;
  }

  for (const auto& [ids, expected] : expected_num_obs) {
    const auto& [metric_id, report_id] = ids;
    pointer = rapidjson::Pointer("/payload/root/cobalt_app/core/observations_stored/report_1-" +
                                 std::to_string(project_id) + "-" + std::to_string(metric_id) +
                                 "-" + std::to_string(report_id));
    value = rapidjson::GetValueByPointerWithDefault(inspect, pointer, -1);
    if (value.GetInt64() != static_cast<int64_t>(expected)) {
      FX_LOGS(ERROR) << "Expected " << expected
                     << " observations counted in Inspect for report MetricID " << metric_id
                     << " ReportId " << report_id << ", found "
                     << (value.GetInt64() == -1 ? "none" : std::to_string(value.GetInt64()))
                     << "\nFull inspect data: " << inspect_json;
      return false;
    }
  }

  return true;
}

// INTEGER metrics for update_duration_new, streaming_time_new and application_memory_new.
bool TestLogInteger(CobaltTestAppLogger* logger, SystemClockInterface* clock,
                    fuchsia::cobalt::ControllerSyncPtr* cobalt_controller,
                    const size_t backfill_days, uint32_t project_id) {
  FX_LOGS(INFO) << "========================";
  FX_LOGS(INFO) << "TestLogInteger";

  // All data for a single report is aggregated into a single observation.
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expected_num_obs = {
      {{cobalt_registry::kUpdateDurationNewMetricId,
        cobalt_registry::kUpdateDurationNewUpdateDurationTimingStatsReportId},
       1},
      {{cobalt_registry::kStreamingTimeNewMetricId,
        cobalt_registry::kStreamingTimeNewStreamingTimePerDeviceTotalReportId},
       1},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::kApplicationMemoryNewApplicationMemoryHistogramsReportId},
       1},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::
            kApplicationMemoryNewApplicationMemoryHistogramsLinearConstantWidthReportId},
       1},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::kApplicationMemoryNewApplicationMemoryStatsReportId},
       1},
  };
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expect_no_obs = {
      {{cobalt_registry::kUpdateDurationNewMetricId,
        cobalt_registry::kUpdateDurationNewUpdateDurationTimingStatsReportId},
       0},
      {{cobalt_registry::kStreamingTimeNewMetricId,
        cobalt_registry::kStreamingTimeNewStreamingTimePerDeviceTotalReportId},
       0},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::kApplicationMemoryNewApplicationMemoryHistogramsReportId},
       0},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::
            kApplicationMemoryNewApplicationMemoryHistogramsLinearConstantWidthReportId},
       0},
      {{cobalt_registry::kApplicationMemoryNewMetricId,
        cobalt_registry::kApplicationMemoryNewApplicationMemoryStatsReportId},
       0},
  };

  uint32_t day_index = CurrentDayIndex(clock);

  // For each of the two event_codes, log one observation with an integer value.
  for (uint32_t error_name_index : kUpdateDurationNewErrorNameIndices) {
    for (uint32_t stage_index : kUpdateDurationNewStageIndices) {
      for (int64_t value : kUpdateDurationNewValues) {
        if (!logger->LogInteger(cobalt_registry::kUpdateDurationNewMetricId,
                                {error_name_index, stage_index}, value)) {
          FX_LOGS(INFO) << "LogInteger(" << cobalt_registry::kUpdateDurationNewMetricId
                        << ", { error_name: " << error_name_index
                        << ", update_duration_stage: " << stage_index << " }, " << value << ")";
          FX_LOGS(INFO) << "TestLogInteger : FAIL";
          return false;
        }
      }
    }
  }

  for (uint32_t type_index : kStreamingTimeNewTypeIndices) {
    for (uint32_t mod_name_index : kStreamingTimeNewModuleNameIndices) {
      for (int64_t duration : kStreamingTimeNewValues) {
        if (!logger->LogInteger(cobalt_registry::kStreamingTimeNewMetricId,
                                {type_index, mod_name_index}, duration)) {
          FX_LOGS(INFO) << "LogInteger(" << cobalt_registry::kStreamingTimeNewMetricId
                        << ", { type: " << type_index << ", module_name: " << mod_name_index
                        << " }, " << duration << ")";
          FX_LOGS(INFO) << "TestLogInteger: FAIL";
          return false;
        }
      }
    }
  }

  for (uint32_t memory_type_index : kApplicationMemoryNewMemoryTypeIndices) {
    for (uint32_t app_name_index : kApplicationMemoryNewApplicationNameIndices) {
      for (int64_t value : kApplicationMemoryNewValues) {
        if (!logger->LogInteger(cobalt_registry::kApplicationMemoryNewMetricId,
                                {memory_type_index, app_name_index}, value)) {
          FX_LOGS(INFO) << "LogInteger(" << cobalt_registry::kApplicationMemoryNewMetricId
                        << ", { memory_type: " << memory_type_index
                        << ", application_name: " << app_name_index << " }, " << value << ")";
          FX_LOGS(INFO) << "TestLogInteger: FAIL";
          return false;
        }
      }
    }
  }

  if (CurrentDayIndex(clock) != day_index) {
    // TODO(b/278930366) The date has changed mid-test. We are currently unable to
    // deal with this so we fail this test and our caller may try again.
    FX_LOGS(INFO) << "Quitting test because the date has changed mid-test.";
    return false;
  }

  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogInteger : FAIL";
    return false;
  }
  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expect_no_obs)) {
    FX_LOGS(INFO) << "TestLogInteger : FAIL";
    return false;
  }
  if (!CheckInspectData(logger, project_id, LoggerMethod::LogInteger,
                        std::size(kUpdateDurationNewErrorNameIndices) *
                                std::size(kUpdateDurationNewStageIndices) *
                                std::size(kUpdateDurationNewValues) +
                            std::size(kStreamingTimeNewTypeIndices) *
                                std::size(kStreamingTimeNewModuleNameIndices) *
                                std::size(kStreamingTimeNewValues) +
                            std::size(kApplicationMemoryNewMemoryTypeIndices) *
                                std::size(kApplicationMemoryNewApplicationNameIndices) *
                                std::size(kApplicationMemoryNewValues),
                        expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogInteger : FAIL";
    return false;
  }
  return SendAndCheckSuccess("TestLogInteger", logger);
}

// OCCURRENCE metrics for features_active_new, file_system_cache_misses_new,
// connection_attempts_new, and error_occurred_new
bool TestLogOccurrence(CobaltTestAppLogger* logger, SystemClockInterface* clock,
                       fuchsia::cobalt::ControllerSyncPtr* cobalt_controller,
                       const size_t backfill_days, uint32_t project_id) {
  FX_LOGS(INFO) << "========================";
  FX_LOGS(INFO) << "TestLogOccurrence";

  // All occurrence count data for a single report is aggregated into a single observation, with the
  // exception of ErrorCountsExperiment report which uses REPORT_ALL.
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expected_num_obs = {
      {{cobalt_registry::kFeaturesActiveNewMetricId,
        cobalt_registry::kFeaturesActiveNewFeaturesActiveUniqueDevicesReportId},
       1},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissCountsReportId},
       1},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissHistogramsReportId},
       1},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissStatsReportId},
       1},
      {{cobalt_registry::kConnectionAttemptsNewMetricId,
        cobalt_registry::kConnectionAttemptsNewConnectionAttemptsPerDeviceCountReportId},
       1},
      {{cobalt_registry::kErrorOccurredNewMetricId,
        cobalt_registry::kErrorOccurredNewErrorCountsExperimentReportId},
       // This metric is logged with 3 distinct experiment ids, and this report uses
       // system_profile_selection: REPORT_ALL, so there will be 3 observations generated.
       3},
  };
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expect_no_obs{
      {{cobalt_registry::kFeaturesActiveNewMetricId,
        cobalt_registry::kFeaturesActiveNewFeaturesActiveUniqueDevicesReportId},
       0},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissCountsReportId},
       0},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissHistogramsReportId},
       0},
      {{cobalt_registry::kFileSystemCacheMissesNewMetricId,
        cobalt_registry::kFileSystemCacheMissesNewFileSystemCacheMissStatsReportId},
       0},
      {{cobalt_registry::kConnectionAttemptsNewMetricId,
        cobalt_registry::kConnectionAttemptsNewConnectionAttemptsPerDeviceCountReportId},
       0},
      {{cobalt_registry::kErrorOccurredNewMetricId,
        cobalt_registry::kErrorOccurredNewErrorCountsExperimentReportId},
       0},
  };

  uint32_t day_index = CurrentDayIndex(clock);

  for (uint32_t skill_index : kFeaturesActiveNewSkillIndices) {
    for (uint64_t count : kFeaturesActiveNewCounts) {
      if (!logger->LogOccurrence(cobalt_registry::kFeaturesActiveNewMetricId, {skill_index},
                                 count)) {
        FX_LOGS(INFO) << "LogOccurrence(" << cobalt_registry::kFeaturesActiveNewMetricId
                      << ", { skill: " << skill_index << " }, " << count << ")";
        FX_LOGS(INFO) << "TestLogOccurrence : FAIL";
        return false;
      }
    }
  }

  for (uint32_t state_index : kFileSystemCacheMissesNewEncryptionStateIndices) {
    for (uint32_t type_index : kFileSystemCacheMissesNewFileSystemTypeIndices) {
      for (int64_t count : kFileSystemCacheMissesNewCounts) {
        if (!logger->LogOccurrence(cobalt_registry::kFileSystemCacheMissesNewMetricId,
                                   {state_index, type_index}, count)) {
          FX_LOGS(INFO) << "LogOccurrence(" << cobalt_registry::kFileSystemCacheMissesNewMetricId
                        << ", { encryption_state: " << state_index
                        << ", file_system_type: " << type_index << " }, " << count << ")";
          FX_LOGS(INFO) << "TestLogOccurrence: FAIL";
          return false;
        }
      }
    }
  }

  for (uint32_t status_index : kConnectionAttemptsNewStatusIndices) {
    for (uint32_t host_index : kConnectionAttemptsNewHostNameIndices) {
      for (int64_t count : kConnectionAttemptsNewCounts) {
        if (!logger->LogOccurrence(cobalt_registry::kConnectionAttemptsNewMetricId,
                                   {status_index, host_index}, count)) {
          FX_LOGS(INFO) << "LogOccurrence(" << cobalt_registry::kConnectionAttemptsNewMetricId
                        << ", { status: " << status_index << ", host_name: " << host_index << " }, "
                        << count << ")";
          FX_LOGS(INFO) << "TestLogOccurrence: FAIL";
          return false;
        }
      }
    }
  }

  for (uint32_t index : kErrorOccurredNewIndicesToUse) {
    for (int64_t count : kErrorOccurredNewCounts) {
      ExperimentArm arm = kExperiment;
      if (index % 2 == 0) {
        arm = kControl;
      }
      if (index == 0) {
        arm = kNone;
      }
      if (!logger->LogOccurrence(cobalt_registry::kErrorOccurredNewMetricId, {index}, count, arm)) {
        FX_LOGS(INFO) << "LogOccurrence(" << cobalt_registry::kErrorOccurredNewMetricId
                      << ", { index: " << index << " }, " << count << ")";
        FX_LOGS(INFO) << "TestLogOccurrence: FAIL";
        return false;
      }
    }
  }

  if (CurrentDayIndex(clock) != day_index) {
    // TODO(b/278930366) The date has changed mid-test. We are currently unable to
    // deal with this so we fail this test and our caller may try again.
    FX_LOGS(INFO) << "Quitting test because the date has changed mid-test.";
    return false;
  }

  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogOccurrence : FAIL";
    return false;
  }
  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expect_no_obs)) {
    FX_LOGS(INFO) << "TestLogOccurrence : FAIL";
    return false;
  }
  if (!CheckInspectData(
          logger, project_id, LoggerMethod::LogOccurrence,
          std::size(kFeaturesActiveNewSkillIndices) * std::size(kFeaturesActiveNewCounts) +
              std::size(kFileSystemCacheMissesNewEncryptionStateIndices) *
                  std::size(kFileSystemCacheMissesNewFileSystemTypeIndices) *
                  std::size(kFileSystemCacheMissesNewCounts) +
              std::size(kConnectionAttemptsNewStatusIndices) *
                  std::size(kConnectionAttemptsNewHostNameIndices) *
                  std::size(kConnectionAttemptsNewCounts) +
              std::size(kErrorOccurredNewIndicesToUse) * std::size(kErrorOccurredNewCounts),
          expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogOccurrence : FAIL";
    return false;
  }
  return SendAndCheckSuccess("TestLogOccurrence", logger);
}

// power_usage_new and bandwidth_usage_new using INTEGER_HISTOGRAM metric.
//
// For each event vector, log one observation in each histogram bucket, using
// decreasing values per bucket.
bool TestLogIntegerHistogram(CobaltTestAppLogger* logger, SystemClockInterface* clock,
                             fuchsia::cobalt::ControllerSyncPtr* cobalt_controller,
                             const size_t backfill_days, uint32_t project_id) {
  FX_LOGS(INFO) << "========================";
  FX_LOGS(INFO) << "TestLogIntegerHistogram";
  std::map<uint32_t, uint64_t> histogram;

  // All integer histogram data is aggregated into a single observation.
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expected_num_obs = {
      {{cobalt_registry::kPowerUsageNewMetricId,
        cobalt_registry::kPowerUsageNewPowerUsageHistogramsReportId},
       1},
      {{cobalt_registry::kBandwidthUsageNewMetricId,
        cobalt_registry::kBandwidthUsageNewBandwidthUsageHistogramsReportId},
       1},
  };
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expect_no_obs = {
      {{cobalt_registry::kPowerUsageNewMetricId,
        cobalt_registry::kPowerUsageNewPowerUsageHistogramsReportId},
       0},
      {{cobalt_registry::kBandwidthUsageNewMetricId,
        cobalt_registry::kBandwidthUsageNewBandwidthUsageHistogramsReportId},
       0},
  };

  uint32_t day_index = CurrentDayIndex(clock);

  // Set up and send power_usage_new histograms.
  for (uint32_t bucket = 0; bucket < kPowerUsageNewBuckets; bucket++) {
    histogram[bucket] = kPowerUsageNewBuckets - bucket + 1;
  }
  for (uint32_t state_index : kPowerUsageNewApplicationStateIndices) {
    for (uint32_t app_name_index : kPowerUsageNewApplicationNameIndices) {
      if (!logger->LogIntegerHistogram(cobalt_registry::kPowerUsageNewMetricId,
                                       {state_index, app_name_index}, histogram)) {
        FX_LOGS(INFO) << "LogIntegerHistogram(" << cobalt_registry::kPowerUsageNewMetricId
                      << ", { application_state: " << state_index
                      << ", application_name: " << app_name_index << " }, buckets["
                      << kPowerUsageNewBuckets << "])";
        FX_LOGS(INFO) << "TestLogIntegerHistogram : FAIL";
        return false;
      }
    }
  }

  histogram.clear();

  // Set up and send bandwidth_usage_new histograms.
  for (uint32_t bucket = 0; bucket < kBandwidthUsageNewBuckets; bucket++) {
    histogram[bucket] = kBandwidthUsageNewBuckets - bucket + 1;
  }
  for (uint32_t state_index : kBandwidthUsageNewApplicationStateIndices) {
    for (uint32_t app_name_index : kBandwidthUsageNewApplicationNameIndices) {
      if (!logger->LogIntegerHistogram(cobalt_registry::kBandwidthUsageNewMetricId,
                                       {state_index, app_name_index}, histogram)) {
        FX_LOGS(INFO) << "LogIntegerHistogram(" << cobalt_registry::kBandwidthUsageNewMetricId
                      << ", { application_state: " << state_index
                      << ", application_name: " << app_name_index << " }, buckets["
                      << kBandwidthUsageNewBuckets << "])";
        FX_LOGS(INFO) << "TestLogIntegerHistogram : FAIL";
        return false;
      }
    }
  }

  if (CurrentDayIndex(clock) != day_index) {
    // TODO(b/278930366) The date has changed mid-test. We are currently unable to
    // deal with this so we fail this test and our caller may try again.
    FX_LOGS(INFO) << "Quitting test because the date has changed mid-test.";
    return false;
  }

  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogIntegerHistogram : FAIL";
    return false;
  }
  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expect_no_obs)) {
    FX_LOGS(INFO) << "TestLogIntegerHistogram : FAIL";
    return false;
  }
  if (!CheckInspectData(logger, project_id, LoggerMethod::LogIntegerHistogram,
                        std::size(kPowerUsageNewApplicationStateIndices) *
                                std::size(kPowerUsageNewApplicationNameIndices) +
                            std::size(kBandwidthUsageNewApplicationStateIndices) *
                                std::size(kBandwidthUsageNewApplicationNameIndices),
                        expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogIntegerHistogram : FAIL";
    return false;
  }
  return SendAndCheckSuccess("TestLogIntegerHistogram", logger);
}

bool CheckInspectData(uint32_t id, std::map<uint32_t, uint32_t> map, int i, size_t i_1);
// error_occurred_components using STRING metric.
//
// For each of the three event_codes, log each of the five application components.
bool TestLogString(CobaltTestAppLogger* logger, SystemClockInterface* clock,
                   fuchsia::cobalt::ControllerSyncPtr* cobalt_controller,
                   const size_t backfill_days, uint32_t project_id) {
  FX_LOGS(INFO) << "========================";
  FX_LOGS(INFO) << "TestLogString";

  // All string data is aggregated into a single observation.
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expected_num_obs;
  std::map<std::pair<uint32_t, uint32_t>, uint64_t> expect_no_obs;
  expected_num_obs[{cobalt_registry::kErrorOccurredComponentsMetricId,
                    cobalt_registry::kErrorOccurredComponentsErrorCountsReportId}] = 1;
  expect_no_obs[{cobalt_registry::kErrorOccurredComponentsMetricId,
                 cobalt_registry::kErrorOccurredComponentsErrorCountsReportId}] = 0;

  uint32_t day_index = CurrentDayIndex(clock);
  for (uint32_t status_index : kErrorOccurredComponentsStatusIndices) {
    for (std::string component : kApplicationComponentNames) {
      if (!logger->LogString(cobalt_registry::kErrorOccurredComponentsMetricId, {status_index},
                             component)) {
        FX_LOGS(INFO) << "LogString(" << cobalt_registry::kErrorOccurredComponentsMetricId
                      << ", { status: " << status_index << " }, " << component << ")";
        FX_LOGS(INFO) << "TestLogString : FAIL";
        return false;
      }
    }
  }

  if (CurrentDayIndex(clock) != day_index) {
    // TODO(b/278930366) The date has changed mid-test. We are currently unable to
    // deal with this so we fail this test and our caller may try again.
    FX_LOGS(INFO) << "Quitting test because the date has changed mid-test.";
    return false;
  }

  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogString : FAIL";
    return false;
  }
  if (!GenerateObsAndCheckCount(day_index, cobalt_controller, project_id, expect_no_obs)) {
    FX_LOGS(INFO) << "TestLogString : FAIL";
    return false;
  }
  if (!CheckInspectData(
          logger, project_id, LoggerMethod::LogString,
          std::size(kErrorOccurredComponentsStatusIndices) * std::size(kApplicationComponentNames),
          expected_num_obs)) {
    FX_LOGS(INFO) << "TestLogString : FAIL";
    return false;
  }
  return SendAndCheckSuccess("TestLogString", logger);
}

}  // namespace cobalt::testapp