gtest_tools.hpp

Go to the documentation of this file.

// Copyright (c) 2019-2021 Simons Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0.txt
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// Authors: Olivier Parcollet, Nils Wentzell
 
#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 <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));