chromium/v8/test/unittests/base/logging-unittest.cc

// Copyright 2015 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "src/base/logging.h"

#include <cstdint>

#include "src/objects/smi.h"
#include "testing/gtest-support.h"

namespace v8 {
namespace base {
namespace logging_unittest {

namespace {

#define CHECK_SUCCEED(NAME, lhs, rhs) …

#define CHECK_FAIL(NAME, lhs, rhs) …

}  // namespace

TEST(LoggingTest, CheckEQImpl) { … }

TEST(LoggingTest, CompareSignedMismatch) { … }

TEST(LoggingTest, CompareAgainstStaticConstPointer) { … }

#define CHECK_BOTH(name, lhs, rhs) …

namespace {
std::string SanitizeRegexp(std::string msg) { … }

std::string FailureMessage(std::string msg) { … }

std::string FailureMessage(const char* msg, const char* lhs, const char* rhs) { … }

std::string LongFailureMessage(const char* msg, const char* lhs,
                               const char* rhs) { … }
}  // namespace

TEST(LoggingTest, CompareWithDifferentSignedness) { … }

TEST(LoggingTest, CompareWithReferenceType) { … }

enum TestEnum1 { … };
enum TestEnum2 : uint16_t { … };
enum class TestEnum3 { … };
enum class TestEnum4 : uint8_t { … };

TEST(LoggingTest, CompareEnumTypes) { … }

class TestClass1 { … };
class TestClass2 { … };
std::ostream& operator<<(std::ostream& str, const TestClass2& val) { … }

TEST(LoggingTest, CompareClassTypes) { … }

TEST(LoggingDeathTest, OutputEnumValues) { … }

enum TestEnum5 { … };
enum class TestEnum6 { … };
std::ostream& operator<<(std::ostream& str, TestEnum5 val) { … }
void operator<<(std::ostream& str, TestEnum6 val) { … }

TEST(LoggingDeathTest, OutputEnumWithOutputOperator) { … }

enum TestEnum7 : uint8_t { … };
enum class TestEnum8 : int8_t { … };

TEST(LoggingDeathTest, OutputSingleCharEnum) { … }

TEST(LoggingDeathTest, OutputLongValues) { … }

TEST(LoggingDeathTest, FatalKills) { … }

TEST(LoggingDeathTest, DcheckIsOnlyFatalInDebug) { … }

namespace {
void DcheckOverrideFunction(const char*, int, const char*) { … }
}  // namespace

TEST(LoggingDeathTest, V8_DcheckCanBeOverridden) { … }

#if defined(DEBUG)
namespace {
int g_log_sink_call_count = …;
void DcheckCountFunction(const char* file, int line, const char* message) { … }

void DcheckEmptyFunction1() { … }
void DcheckEmptyFunction2() { … }

}  // namespace

TEST(LoggingTest, LogFunctionPointers) { … }
#endif  // defined(DEBUG)

TEST(LoggingDeathTest, CheckChars) { … }

}  // namespace logging_unittest
}  // namespace base
}  // namespace v8