gtest_tools.hpp

Go to the documentation of this file.

// Copyright (c) 2019--present, The Simons Foundation
// This file is part of TRIQS/nda and is licensed under the Apache License, Version 2.0.
// SPDX-License-Identifier: Apache-2.0
// See LICENSE in the root of this distribution for details.

 
#pragma once
 
#ifndef NDA_DEBUG
#define NDA_DEBUG
#endif
 
#include "./nda.hpp"
 
#include <gtest/gtest.h>
 
#include <cstdlib>
#include <iostream>
#include <sstream>


template <typename X, typename Y>
::testing::AssertionResult complex_are_close(X const &x, Y const &y, double precision = 1.e-10) {
  using std::abs;
  if (abs(x - y) < precision)
    return ::testing::AssertionSuccess();
  else
    return ::testing::AssertionFailure() << "abs(x - y) = " << abs(x - y) << "\n x = " << x << "\n y = " << y;
}

#define EXPECT_COMPLEX_NEAR(X, ...) EXPECT_TRUE(complex_are_close(X, __VA_ARGS__))

template <typename X, typename Y>
::testing::AssertionResult array_are_equal(X const &x, Y const &y) {
  if (x.shape() != y.shape())
    return ::testing::AssertionFailure() << "Comparing two arrays of different size "
                                         << "\n X = " << x << "\n Y = " << y;
  if (x == y)
    return ::testing::AssertionSuccess();
  else
    return ::testing::AssertionFailure() << "Arrays have different elements\n X = " << x << "\n Y = " << y;
}

#define EXPECT_EQ_ARRAY(X, Y) EXPECT_TRUE(array_are_equal(X, Y));

#define EXPECT_ARRAY_EQ(X, Y) EXPECT_TRUE(array_are_equal(X, Y));

template <typename X, typename Y>
::testing::AssertionResult array_are_close(X const &x, Y const &y, double precision = 1.e-10) {
  nda::array<nda::get_value_t<X>, nda::get_rank<X>> x_reg = x;
  nda::array<nda::get_value_t<X>, nda::get_rank<X>> y_reg = y;
 
  // check their shapes
  if (x_reg.shape() != y_reg.shape())
    return ::testing::AssertionFailure() << "Comparing two arrays of different size "
                                         << "\n X = " << x_reg << "\n Y = " << y_reg;
 
  // empty arrays are considered equal
  if (x_reg.size() == 0) return ::testing::AssertionSuccess();
 
  // check their difference
  const auto maxdiff = max_element(abs(make_regular(x_reg - y_reg)));
  if (maxdiff < precision)
    return ::testing::AssertionSuccess();
  else
    return ::testing::AssertionFailure() << "max_element(abs(X - Y)) = " << maxdiff << "\n X = " << x_reg << "\n Y = " << y_reg;
}

#define EXPECT_ARRAY_NEAR(X, ...) EXPECT_TRUE(array_are_close(X, __VA_ARGS__))

template <nda::MemoryArray X, nda::MemoryArray Y>
::testing::AssertionResult array_are_rel_close(X const &x, Y const &y, double precision = 1.e-10) {
  // check their shapes
  if (x.shape() != y.shape())
    return ::testing::AssertionFailure() << "Comparing two arrays of different size "
                                         << "\n X = " << x << "\n Y = " << y;
 
  // empty arrays are considered equal
  if (x.size() == 0) return ::testing::AssertionSuccess();
 
  // find the largest elementwise relative difference |x - y| / max(|x|, |y|)
  double maxreldiff = 0.0;
  nda::for_each(x.shape(), [&](auto... idx) {
    using std::abs, std::max;
    auto const scale = max(abs(x(idx...)), abs(y(idx...)));
    if (scale != 0) maxreldiff = max(maxreldiff, abs(x(idx...) - y(idx...)) / scale);
  });
 
  if (maxreldiff < precision)
    return ::testing::AssertionSuccess();
  else
    return ::testing::AssertionFailure() << "max(abs(X - Y) / max(abs(X), abs(Y))) = " << maxreldiff << "\n X = " << x << "\n Y = " << y;
}

#define EXPECT_ARRAY_REL_NEAR(X, ...) EXPECT_TRUE(array_are_rel_close(X, __VA_ARGS__))

template <typename X>
::testing::AssertionResult array_almost_zero(X const &x) {
  nda::array<nda::get_value_t<X>, nda::get_rank<X>> x_reg = x;
 
  constexpr double eps = 1.e-10;
  const auto max       = max_element(abs(x_reg));
  if (x_reg.size() == 0 || max < eps)
    return ::testing::AssertionSuccess();
  else
    return ::testing::AssertionFailure() << "max_element(abs(X)) = " << max << "\n X = " << x_reg;
}

#define EXPECT_ARRAY_ZERO(X) EXPECT_TRUE(array_almost_zero(X))

template <typename X, typename Y>
::testing::AssertionResult generic_are_near(X const &x, Y const &y) {
  double precision = 1.e-12;
  using std::abs;
  if (abs(x - y) > precision)
    return ::testing::AssertionFailure() << "X = " << x << " and Y = " << y << " are different. \n Difference is: " << abs(x - y);
  return ::testing::AssertionSuccess();
}

#define EXPECT_CLOSE(X, Y) EXPECT_TRUE(generic_are_near(X, Y));