tests/test_utils.hpp - with_cpu - vuron/adept

tests/test_utils.hpp
76 строк3 KB
kolkir
Make possible to skip tests
06 апр 2025, 22:19
06 апр 2025, 22:1914539b9
#pragma once

#include <adept/dispatch/dispatcher.hpp>
#include <adept/tensor.hpp>
#include <tuple>
#include <vector>

#include "catch.hpp"

#define TEST_VARIANTS                                                                           \
  ((device_t Device, backend_t Backend, typename T), Device, Backend, T),                       \
      (device_t::CPU, backend_t::SIMD, float32_t), (device_t::CPU, backend_t::SIMD, float64_t), \
      (device_t::CPU, backend_t::SIMD, int32_t), (device_t::GPU, backend_t::Vulkan, float32_t)

namespace adept::test {

template <typename T>
using Data = std::vector<T>;

inline void apply_backend(device_t device, backend_t backend) {
  if (!Dispatcher::instance().has_backend(device, backend))
    SKIP("There are no " << device << " with " << backend << " in the current system");
  Dispatcher::instance().set_current_backend(device, backend);
}

template <typename T, template <class> class Op>
std::tuple<Data<T>, Data<T>, Data<T>> make_test_data() {
  Data<T> x = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  Data<T> y = {7, 8, 1, 3, 9, 4, 5, 2, 6};
  Data<T> z;
  std::transform(x.begin(), x.end(), y.begin(), std::back_inserter(z), Op<T>());
  return {x, y, z};
}

template <typename T, template <class> class Op>
std::tuple<Data<T>, Data<T>, Data<T>> make_scalar_test_data() {
  Data<T> x = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  Data<T> y = {7, 7, 7, 7, 7, 7, 7, 7, 7};
  Data<T> z;
  std::transform(x.begin(), x.end(), y.begin(), std::back_inserter(z), Op<T>());
  return {x, y, z};
}

template <typename T, template <class> class Op>
std::tuple<Data<T>, Data<T>, Data<T>> make_row_broadcast_test_data() {
  Data<T> x = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  Data<T> y_t = {7, 8, 9, 7, 8, 9, 7, 8, 9};
  Data<T> y = {7, 8, 9};
  Data<T> z;
  std::transform(x.begin(), x.end(), y_t.begin(), std::back_inserter(z), Op<T>());
  return {x, y, z};
}

template <typename T, template <class> class Op>
std::tuple<Data<T>, Data<T>, Data<T>> make_col_broadcast_test_data() {
  Data<T> x = {1, 2, 3, 4, 5, 6, 7, 8, 9};
  Data<T> y_t = {7, 7, 7, 8, 8, 8, 9, 9, 9};
  Data<T> y = {7, 8, 9};
  Data<T> z;
  std::transform(x.begin(), x.end(), y_t.begin(), std::back_inserter(z), Op<T>());
  return {x, y, z};
}

template <typename T>
void equals(const Data<T>& expected, const Tensor& actual) {
  Indexer idx(&actual.properties().shape);
  for (size_t i = 0; i < expected.size(); ++i) {
    auto coords = idx.idxunravel(i);
    if constexpr (std::is_floating_point_v<T>) {
      REQUIRE_THAT(actual.at<T>(coords), Catch::WithinRel(expected[i], static_cast<T>(0.001)));
    } else {
      REQUIRE(actual.at<T>(coords) == expected[i]);
    }
  }
}
}  // namespace adept::test