error_unittest.cc

// Copyright lowRISC contributors (OpenTitan project).
// Licensed under the Apache License, Version 2.0, see LICENSE for details.
// SPDX-License-Identifier: Apache-2.0
 
#include "sw/device/silicon_creator/lib/error.h"
 
#include <climits>
#include <cstdint>
#include <map>
#include <string>
 
#include "gtest/gtest.h"
#include "sw/device/lib/base/bitfield.h"
#include "sw/device/silicon_creator/lib/error_unittest_util.h"
 
namespace error_unittest {
namespace {
 
constexpr int kMinimumHammingDistance = 6;
 
rom_error_t ReturnIfError(rom_error_t value) {
  RETURN_IF_ERROR(value);
 
  // Return something other than kErrorOk just in case RETURN_IF_ERROR
  // was wrong.
  return static_cast<rom_error_t>(0);
}
 
int HammingDistance(uint32_t a, uint32_t b) {
  // The hamming distance is the number of bits different between the two words.
  return bitfield_popcount32(a ^ b);
}
 
// Checks that there are no duplicate values in the error definitions.
TEST(ErrorsTest, NoDuplicateValues) {
  const auto &errors = GetErrorMap();
 
  for (auto a = errors.begin(); a != errors.end(); ++a) {
    for (auto b = a; b != errors.end(); ++b) {
      if (a == b) {
        continue;
      }
      EXPECT_NE(a->second, b->second)
          << "Error codes '" << a->first << "' and '" << b->first
          << "' have the same value.";
    }
  }
}
 
// Checks that the RETURN_IF_ERROR macro works as expected.
TEST(ErrorsTest, CheckReturnIfError) {
  EXPECT_EQ(kErrorUnknown, ReturnIfError(kErrorUnknown));
 
  rom_error_t ok = ReturnIfError(kErrorOk);
  EXPECT_EQ(0, static_cast<int>(ok));
}
 
TEST(ErrorsTest, CheckHammingDistanceToOk) {
  const auto &errors = GetErrorMap();
  int max_distance = 0;
  int min_distance = INT_MAX;
  int distance;
 
  for (const auto &a : errors) {
    if (a.second == kErrorOk) {
      distance = HammingDistance(a.second, 0);
      std::cout << "Hamming distance between '" << a.first
                << "' and zero: " << distance << std::endl;
    } else {
      distance = HammingDistance(a.second, kErrorOk);
      std::cout << "Hamming distance between '" << a.first
                << "' and kErrorOk: " << distance << std::endl;
    }
    EXPECT_GE(distance, kMinimumHammingDistance);
    min_distance = std::min(min_distance, distance);
    max_distance = std::max(max_distance, distance);
  }
  std::cout << "Minimum hamming distance observed: " << min_distance
            << std::endl;
  std::cout << "Maximum hamming distance observed: " << max_distance
            << std::endl;
}
 
}  // namespace
}  // namespace error_unittest