Assertion.h

Aller à la documentation de ce fichier.

// -*- tab-width: 2; indent-tabs-mode: nil; coding: utf-8-with-signature -*-
//-----------------------------------------------------------------------------
// Copyright 2000-2022 CEA (www.cea.fr) IFPEN (www.ifpenergiesnouvelles.com)
// See the top-level COPYRIGHT file for details.
// SPDX-License-Identifier: Apache-2.0
//-----------------------------------------------------------------------------
/*---------------------------------------------------------------------------*/
/* Assertion.h                                                 (C) 2000-2020 */
/*                                                                           */
/* Ensemble d'assertions utilisées pour les tests unitaires.                 */
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
#ifndef ARCANE_ASSERTION_H
#define ARCANE_ASSERTION_H
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#include "arcane/utils/TraceInfo.h"
#include "arcane/utils/Numeric.h"
#include "arcane/ArcaneTypes.h"
#include "arcane/ArcaneException.h"
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
namespace Arcane
{
class IParallelMng;
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
class ARCANE_CORE_EXPORT Assertion
{
 private:
 
  void _checkAssertion(bool is_error,const TraceInfo& where,
                       const String& expected, const String& actual, IParallelMng* pm);
 
 public:
 
  void fail(const TraceInfo& where)
  {
    throw AssertionException(where);
  }
 
 void assertTrue(const TraceInfo& where, bool condition, IParallelMng* pm = nullptr)
  {
    bool is_error = (!condition);
    _checkAssertion(is_error, where, "true", "false", pm);
  }
 
  void assertFalse(const TraceInfo& where, bool condition, IParallelMng* pm = nullptr)
  {
    bool is_error = (condition);
    _checkAssertion(is_error, where, "false", "true", pm);
  }
 
  void assertEqual(const TraceInfo& where, const String& expected,
                   const String& actual, IParallelMng* pm = nullptr)
  {
    bool is_error = (expected != actual);
    _checkAssertion(is_error,where,expected,actual,pm);
  }
 
  template<typename T>
  void assertEqual(const TraceInfo& where, const T& expected, const T& actual, IParallelMng* pm = nullptr)
  {
    // utilisation de l'operateur == pour les types numeriques et non !=
    bool is_error = (! (expected == actual));
    _checkAssertion(is_error,where,String::fromNumber(expected),String::fromNumber(actual),pm);
  }
 
  template<typename T>
  void assertNearlyEqual(const TraceInfo& where, const T& expected,
                         const T& actual, IParallelMng* pm = nullptr)
  {
    bool is_error = (!math::isNearlyEqual(expected,actual));
    _checkAssertion(is_error,where,String::fromNumber(expected),String::fromNumber(actual),pm);
  }
 
  template<typename T>
  void assertNearlyZero(const TraceInfo& where, const T& actual, IParallelMng* pm = nullptr)
  {
    bool is_error = (!math::isNearlyZero(actual));
    _checkAssertion(is_error, where, "0", String::fromNumber(actual),pm);
  }
 
  template<typename T>
  void assertNearlyEqualWithEpsilon(const TraceInfo& where, const T& expected,
                                    const T& actual,const T& epsilon, IParallelMng* pm = nullptr)
  {
    bool is_error = (!math::isNearlyEqualWithEpsilon(expected,actual,epsilon));
    _checkAssertion(is_error, where, String::fromNumber(expected), String::fromNumber(actual), pm);
  }
 
  template<typename T>
  void assertNearlyZeroWithEpsilon(const TraceInfo& where, const T& actual,
                                   const T& epsilon, IParallelMng* pm = nullptr)
  {
    bool is_error = (!math::isNearlyZeroWithEpsilon(actual,epsilon));
    _checkAssertion(is_error, where, "0", String::fromNumber(actual), pm);
  }
};
 
#define FAIL fail(A_FUNCINFO)
 
#define ASSERT_TRUE(condition) \
assertTrue(A_FUNCINFO, condition)
 
#define PARALLEL_ASSERT_TRUE(condition, parallel_mng) \
  assertTrue(A_FUNCINFO, condition, parallel_mng)
 
#define ASSERT_FALSE(condition) \
assertFalse(A_FUNCINFO, condition)
 
#define PARALLEL_ASSERT_FALSE(condition, parallel_mng)  \
  assertFalse(A_FUNCINFO, condition, parallel_mng)
 
#define ASSERT_EQUAL(expected, actual) \
assertEqual(A_FUNCINFO, expected, actual)
 
#define PARALLEL_ASSERT_EQUAL(expected, actual, parallel_mng)  \
  assertEqual(A_FUNCINFO, expected, actual, parallel_mng)
 
#define ASSERT_NEARLY_EQUAL(expected, actual) \
assertNearlyEqual(A_FUNCINFO, expected, actual)
 
#define PARALLEL_ASSERT_NEARLY_EQUAL(expected, actual, parallel_mng) \
  assertNearlyEqual(A_FUNCINFO, expected, actual, parallel_mng)
 
#define ASSERT_NEARLY_ZERO(actual) \
assertNearlyZero(A_FUNCINFO, actual)
 
#define PARALLEL_ASSERT_NEARLY_ZERO(actual, parallel_mng) \
  assertNearlyZero(A_FUNCINFO, actual, parallel_mng)
 
#define ASSERT_NEARLY_EQUAL_EPSILON(expected, actual, epsilon) \
assertNearlyEqualWithEpsilon(A_FUNCINFO, expected, actual, epsilon)
 
#define PARALLEL_ASSERT_NEARLY_EQUAL_EPSILON(expected, actual, epsilon, parallel_mng) \
  assertNearlyEqualWithEpsilon(A_FUNCINFO, expected, actual, epsilon, parallel_mng)
 
#define ASSERT_NEARLY_ZERO_EPSILON(actual,epsilon) \
assertNearlyZeroWithEpsilon(A_FUNCINFO, actual, epsilon)
 
#define PARALLEL_ASSERT_NEARLY_ZERO_EPSILON(actual,epsilon, parallel_mng)  \
  assertNearlyZeroWithEpsilon(A_FUNCINFO, actual, epsilon, parallel_mng)
 
#define ASSERT_EQUALS(expected, actual) \
assertEqual(A_FUNCINFO, expected, actual)
 
#define ASSERT_NEARLY_EQUALS(expected, actual) \
assertNearlyEqual(A_FUNCINFO, expected, actual)
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
} // End namespace Arcane
 
/*---------------------------------------------------------------------------*/
/*---------------------------------------------------------------------------*/
 
#endif