// Copyright 2020 The Pigweed Authors
//
// 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
//
//     https://www.apache.org/licenses/LICENSE-2.0
//
// 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.
#pragma once

// Note: This file depends on the backend header already being included.

#include "pw_preprocessor/macro_arg_count.h"

// Define PW_ASSERT_ENABLE_DCHECK, which controls whether DCHECKs are enabled.
#if !defined(PW_ASSERT_ENABLE_DCHECK)
#if defined(NDEBUG)
// Release mode; remove all DCHECK*() asserts.
#define PW_ASSERT_ENABLE_DCHECK 0
#else
// Debug mode; keep all DCHECK*() asserts.
#define PW_ASSERT_ENABLE_DCHECK 1
#endif  // defined (NDEBUG)
#endif  // !defined(PW_ASSERT_ENABLE_DCHECK)

// PW_CRASH - Crash the system, with a message.
#define PW_CRASH(message, ...) \
  PW_HANDLE_CRASH(message PW_COMMA_ARGS(__VA_ARGS__))

// PW_CHECK - If condition evaluates to false, crash. Message optional.
#define PW_CHECK(condition, ...)                              \
  do {                                                        \
    if (!(condition)) {                                       \
      _PW_CHECK_SELECT_MACRO(                                 \
          #condition, PW_HAS_ARGS(__VA_ARGS__), __VA_ARGS__); \
    }                                                         \
  } while (0)

#define PW_DCHECK(...)         \
  if (PW_ASSERT_ENABLE_DCHECK) \
  PW_CHECK(__VA_ARGS__)

// PW_D?CHECK_<type>_<comparison> macros - Binary comparison asserts.
//
// The below blocks are structured in table form, violating the 80-column
// Pigweed style, in order to make it clearer what is common and what isn't
// between the multitude of assert macro instantiations. To best view this
// section, turn off editor wrapping or make your editor wide.
//
// clang-format off

// Checks for int: LE, LT, GE, GT, EQ.
#define PW_CHECK_INT_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, int, "%d", __VA_ARGS__)
#define PW_CHECK_INT_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, int, "%d", __VA_ARGS__)
#define PW_CHECK_INT_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, int, "%d", __VA_ARGS__)
#define PW_CHECK_INT_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, int, "%d", __VA_ARGS__)
#define PW_CHECK_INT_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, int, "%d", __VA_ARGS__)
#define PW_CHECK_INT_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, int, "%d", __VA_ARGS__)

// Debug checks for int: LE, LT, GE, GT, EQ.
#define PW_DCHECK_INT_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_LE(__VA_ARGS__)
#define PW_DCHECK_INT_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_LT(__VA_ARGS__)
#define PW_DCHECK_INT_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_GE(__VA_ARGS__)
#define PW_DCHECK_INT_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_GT(__VA_ARGS__)
#define PW_DCHECK_INT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_EQ(__VA_ARGS__)
#define PW_DCHECK_INT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_INT_NE(__VA_ARGS__)

// Checks for unsigned int: LE, LT, GE, GT, EQ.
#define PW_CHECK_UINT_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, unsigned int, "%u", __VA_ARGS__)
#define PW_CHECK_UINT_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, unsigned int, "%u", __VA_ARGS__)
#define PW_CHECK_UINT_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, unsigned int, "%u", __VA_ARGS__)
#define PW_CHECK_UINT_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, unsigned int, "%u", __VA_ARGS__)
#define PW_CHECK_UINT_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, unsigned int, "%u", __VA_ARGS__)
#define PW_CHECK_UINT_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, unsigned int, "%u", __VA_ARGS__)

// Debug checks for unsigned int: LE, LT, GE, GT, EQ.
#define PW_DCHECK_UINT_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_LE(__VA_ARGS__)
#define PW_DCHECK_UINT_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_LT(__VA_ARGS__)
#define PW_DCHECK_UINT_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_GE(__VA_ARGS__)
#define PW_DCHECK_UINT_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_GT(__VA_ARGS__)
#define PW_DCHECK_UINT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_EQ(__VA_ARGS__)
#define PW_DCHECK_UINT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_UINT_NE(__VA_ARGS__)

// Checks for pointer: LE, LT, GE, GT, EQ, NE, and NOTNULL.
#define PW_CHECK_PTR_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_PTR_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_PTR_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_PTR_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_PTR_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_PTR_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, void*, "%p", __VA_ARGS__)
#define PW_CHECK_NOTNULL(arga, ...) \
  _PW_CHECK_BINARY_CMP_IMPL(arga, !=, NULL, void*, "%p", __VA_ARGS__)

// Debug checks for pointer: LE, LT, GE, GT, EQ, NE, and NOTNULL.
#define PW_DCHECK_PTR_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_LE(__VA_ARGS__)
#define PW_DCHECK_PTR_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_LT(__VA_ARGS__)
#define PW_DCHECK_PTR_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_GE(__VA_ARGS__)
#define PW_DCHECK_PTR_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_GT(__VA_ARGS__)
#define PW_DCHECK_PTR_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_EQ(__VA_ARGS__)
#define PW_DCHECK_PTR_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_PTR_NE(__VA_ARGS__)
#define PW_DCHECK_NOTNULL(...) \
  if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_NOTNULL(__VA_ARGS__)

// Checks for float: EXACT_LE, EXACT_LT, EXACT_GE, EXACT_GT, EXACT_EQ, EXACT_NE,
// NEAR.
#define PW_CHECK_FLOAT_NEAR(arga, argb, abs_tolerance, ...) \
  _PW_CHECK_FLOAT_NEAR(arga, argb, abs_tolerance, __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_LE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, <=, argb, float, "%f", __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_LT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, < , argb, float, "%f", __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_GE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, >=, argb, float, "%f", __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_GT(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, > , argb, float, "%f", __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_EQ(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, ==, argb, float, "%f", __VA_ARGS__)
#define PW_CHECK_FLOAT_EXACT_NE(arga, argb, ...) _PW_CHECK_BINARY_CMP_IMPL(arga, !=, argb, float, "%f", __VA_ARGS__)

// Debug checks for float: NEAR, EXACT_LE, EXACT_LT, EXACT_GE, EXACT_GT,
// EXACT_EQ.
#define PW_DCHECK_FLOAT_NEAR(...) \
  if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_NEAR(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_LE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_LE(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_LT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_LT(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_GE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_GE(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_GT(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_GT(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_EQ(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_EQ(__VA_ARGS__)
#define PW_DCHECK_FLOAT_EXACT_NE(...) if (PW_ASSERT_ENABLE_DCHECK) PW_CHECK_FLOAT_EXACT_NE(__VA_ARGS__)

// clang-format on

// PW_CHECK - If condition evaluates to false, crash. Message optional.
#define PW_CHECK_OK(status, ...)                          \
  do {                                                    \
    if (status != PW_STATUS_OK) {                         \
      _PW_CHECK_OK_SELECT_MACRO(#status,                  \
                                pw_StatusString(status),  \
                                PW_HAS_ARGS(__VA_ARGS__), \
                                __VA_ARGS__);             \
    }                                                     \
  } while (0)

#define PW_DCHECK_OK(...)      \
  if (PW_ASSERT_ENABLE_DCHECK) \
  PW_CHECK_OK(__VA_ARGS__)

// =========================================================================
// Implementation for PW_CHECK

// Two layers of select macros are used to enable the preprocessor to expand
// macros in the arguments to ultimately token paste the final macro name based
// on whether there are printf-style arguments.
#define _PW_CHECK_SELECT_MACRO(condition, has_args, ...) \
  _PW_CHECK_SELECT_MACRO_EXPANDED(condition, has_args, __VA_ARGS__)

// Delegate to the macro
#define _PW_CHECK_SELECT_MACRO_EXPANDED(condition, has_args, ...) \
  _PW_CHECK_HAS_MSG_##has_args(condition, __VA_ARGS__)

// PW_CHECK version 1: No message or args
#define _PW_CHECK_HAS_MSG_0(condition, ignored_arg) \
  PW_HANDLE_ASSERT_FAILURE(condition, "")

// PW_CHECK version 2: With message (and maybe args)
#define _PW_CHECK_HAS_MSG_1(condition, ...) \
  PW_HANDLE_ASSERT_FAILURE(condition, __VA_ARGS__)

// =========================================================================
// Implementation for PW_CHECK_<type>_<comparison>

// Two layers of select macros are used to enable the preprocessor to expand
// macros in the arguments to ultimately token paste the final macro name based
// on whether there are printf-style arguments.
#define _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(argument_a_str,       \
                                                 argument_a_val,       \
                                                 comparison_op_str,    \
                                                 argument_b_str,       \
                                                 argument_b_val,       \
                                                 type_fmt,             \
                                                 has_args,             \
                                                 ...)                  \
  _PW_CHECK_SELECT_BINARY_COMPARISON_MACRO_EXPANDED(argument_a_str,    \
                                                    argument_a_val,    \
                                                    comparison_op_str, \
                                                    argument_b_str,    \
                                                    argument_b_val,    \
                                                    type_fmt,          \
                                                    has_args,          \
                                                    __VA_ARGS__)

// Delegate to the macro
#define _PW_CHECK_SELECT_BINARY_COMPARISON_MACRO_EXPANDED(argument_a_str,    \
                                                          argument_a_val,    \
                                                          comparison_op_str, \
                                                          argument_b_str,    \
                                                          argument_b_val,    \
                                                          type_fmt,          \
                                                          has_args,          \
                                                          ...)               \
  _PW_CHECK_BINARY_COMPARISON_HAS_MSG_##has_args(argument_a_str,             \
                                                 argument_a_val,             \
                                                 comparison_op_str,          \
                                                 argument_b_str,             \
                                                 argument_b_val,             \
                                                 type_fmt,                   \
                                                 __VA_ARGS__)

// PW_CHECK_BINARY_COMPARISON version 1: No message or args
#define _PW_CHECK_BINARY_COMPARISON_HAS_MSG_0(argument_a_str,    \
                                              argument_a_val,    \
                                              comparison_op_str, \
                                              argument_b_str,    \
                                              argument_b_val,    \
                                              type_fmt,          \
                                              ignored_arg)       \
  PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(argument_a_str,        \
                                          argument_a_val,        \
                                          comparison_op_str,     \
                                          argument_b_str,        \
                                          argument_b_val,        \
                                          type_fmt,              \
                                          "")

// PW_CHECK_BINARY_COMPARISON version 2: With message (and maybe args)
#define _PW_CHECK_BINARY_COMPARISON_HAS_MSG_1(argument_a_str,    \
                                              argument_a_val,    \
                                              comparison_op_str, \
                                              argument_b_str,    \
                                              argument_b_val,    \
                                              type_fmt,          \
                                              ...)               \
  PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(argument_a_str,        \
                                          argument_a_val,        \
                                          comparison_op_str,     \
                                          argument_b_str,        \
                                          argument_b_val,        \
                                          type_fmt,              \
                                          __VA_ARGS__)

// For the binary assertions, this private macro is re-used for almost all of
// the variants. Due to limitations of C formatting, it is necessary to have
// separate macros for the types.
//
// The macro avoids evaluating the arguments multiple times at the cost of some
// macro complexity.
#define _PW_CHECK_BINARY_CMP_IMPL(                                       \
    argument_a, comparison_op, argument_b, type_decl, type_fmt, ...)     \
  do {                                                                   \
    type_decl evaluated_argument_a = (type_decl)(argument_a);            \
    type_decl evaluated_argument_b = (type_decl)(argument_b);            \
    if (!(evaluated_argument_a comparison_op evaluated_argument_b)) {    \
      _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(#argument_a,              \
                                               evaluated_argument_a,     \
                                               #comparison_op,           \
                                               #argument_b,              \
                                               evaluated_argument_b,     \
                                               type_fmt,                 \
                                               PW_HAS_ARGS(__VA_ARGS__), \
                                               __VA_ARGS__);             \
    }                                                                    \
  } while (0)

// Custom implementation for FLOAT_NEAR which is implemented through two
// underlying checks which are not trivially replaced through the use of
// FLOAT_EXACT_LE & FLOAT_EXACT_GE.
#define _PW_CHECK_FLOAT_NEAR(argument_a, argument_b, abs_tolerance, ...)       \
  do {                                                                         \
    PW_CHECK_FLOAT_EXACT_GE(abs_tolerance, 0.0f);                              \
    float evaluated_argument_a = (float)(argument_a);                          \
    float evaluated_argument_b_min = (float)(argument_b)-abs_tolerance;        \
    float evaluated_argument_b_max = (float)(argument_b) + abs_tolerance;      \
    if (!(evaluated_argument_a >= evaluated_argument_b_min)) {                 \
      _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(#argument_a,                    \
                                               evaluated_argument_a,           \
                                               ">=",                           \
                                               #argument_b " - abs_tolerance", \
                                               evaluated_argument_b_min,       \
                                               "%f",                           \
                                               PW_HAS_ARGS(__VA_ARGS__),       \
                                               __VA_ARGS__);                   \
    } else if (!(evaluated_argument_a <= evaluated_argument_b_max)) {          \
      _PW_CHECK_BINARY_COMPARISON_SELECT_MACRO(#argument_a,                    \
                                               evaluated_argument_a,           \
                                               "<=",                           \
                                               #argument_b " + abs_tolerance", \
                                               evaluated_argument_b_max,       \
                                               "%f",                           \
                                               PW_HAS_ARGS(__VA_ARGS__),       \
                                               __VA_ARGS__);                   \
    }                                                                          \
  } while (0)

// =========================================================================
// Implementation for PW_CHECK_OK

// Two layers of select macros are used to enable the preprocessor to expand
// macros in the arguments to ultimately token paste the final macro name based
// on whether there are printf-style arguments.
#define _PW_CHECK_OK_SELECT_MACRO(                    \
    status_expr_str, status_value_str, has_args, ...) \
  _PW_CHECK_OK_SELECT_MACRO_EXPANDED(                 \
      status_expr_str, status_value_str, has_args, __VA_ARGS__)

// Delegate to the macro
#define _PW_CHECK_OK_SELECT_MACRO_EXPANDED(           \
    status_expr_str, status_value_str, has_args, ...) \
  _PW_CHECK_OK_HAS_MSG_##has_args(                    \
      status_expr_str, status_value_str, __VA_ARGS__)

// PW_CHECK_OK version 1: No message or args
#define _PW_CHECK_OK_HAS_MSG_0(status_expr_str, status_value_str, ignored_arg) \
  PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(                                     \
      status_expr_str, status_value_str, "==", "Status::OK", "OK", "%s", "")

// PW_CHECK_OK version 2: With message (and maybe args)
#define _PW_CHECK_OK_HAS_MSG_1(status_expr_str, status_value_str, ...) \
  PW_HANDLE_ASSERT_BINARY_COMPARE_FAILURE(status_expr_str,             \
                                          status_value_str,            \
                                          "==",                        \
                                          "Status::OK",                \
                                          "OK",                        \
                                          "%s",                        \
                                          __VA_ARGS__)

// Define short, usable names if requested. Note that the CHECK() macro will
// conflict with Google Log, which expects stream style logs.
#ifndef PW_ASSERT_USE_SHORT_NAMES
#define PW_ASSERT_USE_SHORT_NAMES 0
#endif

// =========================================================================
// Short name definitions (optional)

// clang-format off
#if PW_ASSERT_USE_SHORT_NAMES

// Checks that always run even in production.
#define CRASH                 PW_CRASH
#define CHECK                 PW_CHECK
#define CHECK_PTR_LE          PW_CHECK_PTR_LE
#define CHECK_PTR_LT          PW_CHECK_PTR_LT
#define CHECK_PTR_GE          PW_CHECK_PTR_GE
#define CHECK_PTR_GT          PW_CHECK_PTR_GT
#define CHECK_PTR_EQ          PW_CHECK_PTR_EQ
#define CHECK_PTR_NE          PW_CHECK_PTR_NE
#define CHECK_NOTNULL         PW_CHECK_NOTNULL
#define CHECK_INT_LE          PW_CHECK_INT_LE
#define CHECK_INT_LT          PW_CHECK_INT_LT
#define CHECK_INT_GE          PW_CHECK_INT_GE
#define CHECK_INT_GT          PW_CHECK_INT_GT
#define CHECK_INT_EQ          PW_CHECK_INT_EQ
#define CHECK_INT_NE          PW_CHECK_INT_NE
#define CHECK_UINT_LE         PW_CHECK_UINT_LE
#define CHECK_UINT_LT         PW_CHECK_UINT_LT
#define CHECK_UINT_GE         PW_CHECK_UINT_GE
#define CHECK_UINT_GT         PW_CHECK_UINT_GT
#define CHECK_UINT_EQ         PW_CHECK_UINT_EQ
#define CHECK_UINT_NE         PW_CHECK_UINT_NE
#define CHECK_FLOAT_NEAR      PW_CHECK_FLOAT_NEAR
#define CHECK_FLOAT_EXACT_LE  PW_CHECK_FLOAT_EXACT_LE
#define CHECK_FLOAT_EXACT_LT  PW_CHECK_FLOAT_EXACT_LT
#define CHECK_FLOAT_EXACT_GE  PW_CHECK_FLOAT_EXACT_GE
#define CHECK_FLOAT_EXACT_GT  PW_CHECK_FLOAT_EXACT_GT
#define CHECK_FLOAT_EXACT_EQ  PW_CHECK_FLOAT_EXACT_EQ
#define CHECK_FLOAT_EXACT_NE  PW_CHECK_FLOAT_EXACT_NE
#define CHECK_OK              PW_CHECK_OK

// Checks that are disabled if NDEBUG is not defined.
#define DCHECK                PW_DCHECK
#define DCHECK_PTR_LE         PW_DCHECK_PTR_LE
#define DCHECK_PTR_LT         PW_DCHECK_PTR_LT
#define DCHECK_PTR_GE         PW_DCHECK_PTR_GE
#define DCHECK_PTR_GT         PW_DCHECK_PTR_GT
#define DCHECK_PTR_EQ         PW_DCHECK_PTR_EQ
#define DCHECK_PTR_NE         PW_DCHECK_PTR_NE
#define DCHECK_NOTNULL        PW_DCHECK_NOTNULL
#define DCHECK_INT_LE         PW_DCHECK_INT_LE
#define DCHECK_INT_LT         PW_DCHECK_INT_LT
#define DCHECK_INT_GE         PW_DCHECK_INT_GE
#define DCHECK_INT_GT         PW_DCHECK_INT_GT
#define DCHECK_INT_EQ         PW_DCHECK_INT_EQ
#define DCHECK_INT_NE         PW_DCHECK_INT_NE
#define DCHECK_UINT_LE        PW_DCHECK_UINT_LE
#define DCHECK_UINT_LT        PW_DCHECK_UINT_LT
#define DCHECK_UINT_GE        PW_DCHECK_UINT_GE
#define DCHECK_UINT_GT        PW_DCHECK_UINT_GT
#define DCHECK_UINT_EQ        PW_DCHECK_UINT_EQ
#define DCHECK_UINT_NE        PW_DCHECK_UINT_NE
#define DCHECK_FLOAT_NEAR     PW_DCHECK_FLOAT_NEAR
#define DCHECK_FLOAT_EXACT_LT PW_DCHECK_FLOAT_EXACT_LT
#define DCHECK_FLOAT_EXACT_LE PW_DCHECK_FLOAT_EXACT_LE
#define DCHECK_FLOAT_EXACT_GT PW_DCHECK_FLOAT_EXACT_GT
#define DCHECK_FLOAT_EXACT_GE PW_DCHECK_FLOAT_EXACT_GE
#define DCHECK_FLOAT_EXACT_EQ PW_DCHECK_FLOAT_EXACT_EQ
#define DCHECK_FLOAT_EXACT_NE PW_DCHECK_FLOAT_EXACT_NE
#define DCHECK_OK             PW_DCHECK_OK

#endif  // PW_ASSERT_SHORT_NAMES
// clang-format on