From 6bf4b90c90f15f4ab60833bddf5b5756d1a6b1f6 Mon Sep 17 00:00:00 2001 From: Elizabeth Alexander Hunt Date: Thu, 2 Jul 2026 11:55:17 -0700 Subject: Init --- .../build/_deps/fmt-src/test/CMakeLists.txt | 245 + .../test/add-subdirectory-test/CMakeLists.txt | 17 + .../fmt-src/test/add-subdirectory-test/main.cc | 5 + .../build/_deps/fmt-src/test/args-test.cc | 186 + .../build/_deps/fmt-src/test/assert-test.cc | 31 + .../build/_deps/fmt-src/test/chrono-test.cc | 643 + .../build/_deps/fmt-src/test/color-test.cc | 72 + .../fmt-src/test/compile-error-test/CMakeLists.txt | 241 + .../build/_deps/fmt-src/test/compile-fp-test.cc | 62 + .../build/_deps/fmt-src/test/compile-test.cc | 392 + .../build/_deps/fmt-src/test/core-test.cc | 978 ++ .../_deps/fmt-src/test/cuda-test/CMakeLists.txt | 73 + .../build/_deps/fmt-src/test/cuda-test/cpp14.cc | 11 + .../_deps/fmt-src/test/cuda-test/cuda-cpp14.cu | 28 + .../build/_deps/fmt-src/test/detect-stdfs.cc | 18 + .../_deps/fmt-src/test/enforce-checks-test.cc | 63 + .../fmt-src/test/find-package-test/CMakeLists.txt | 17 + .../_deps/fmt-src/test/find-package-test/main.cc | 5 + .../build/_deps/fmt-src/test/format-impl-test.cc | 547 + .../build/_deps/fmt-src/test/format-test.cc | 2311 +++ .../_deps/fmt-src/test/fuzzing/CMakeLists.txt | 30 + .../build/_deps/fmt-src/test/fuzzing/README.md | 25 + .../build/_deps/fmt-src/test/fuzzing/build.sh | 90 + .../_deps/fmt-src/test/fuzzing/chrono-duration.cc | 136 + .../_deps/fmt-src/test/fuzzing/chrono-timepoint.cc | 32 + .../build/_deps/fmt-src/test/fuzzing/float.cc | 39 + .../_deps/fmt-src/test/fuzzing/fuzzer-common.h | 77 + .../build/_deps/fmt-src/test/fuzzing/main.cc | 22 + .../build/_deps/fmt-src/test/fuzzing/named-arg.cc | 102 + .../build/_deps/fmt-src/test/fuzzing/one-arg.cc | 92 + .../build/_deps/fmt-src/test/fuzzing/two-args.cc | 106 + .../build/_deps/fmt-src/test/gtest-extra-test.cc | 413 + .../build/_deps/fmt-src/test/gtest-extra.cc | 80 + .../build/_deps/fmt-src/test/gtest-extra.h | 170 + .../build/_deps/fmt-src/test/gtest/CMakeLists.txt | 38 + .../_deps/fmt-src/test/gtest/gmock-gtest-all.cc | 14434 +++++++++++++++++++ .../build/_deps/fmt-src/test/gtest/gmock/gmock.h | 11645 +++++++++++++++ .../_deps/fmt-src/test/gtest/gtest/gtest-spi.h | 238 + .../build/_deps/fmt-src/test/gtest/gtest/gtest.h | 12398 ++++++++++++++++ .../build/_deps/fmt-src/test/header-only-test.cc | 11 + .../build/_deps/fmt-src/test/mock-allocator.h | 64 + .../build/_deps/fmt-src/test/module-test.cc | 572 + .../build/_deps/fmt-src/test/noexception-test.cc | 18 + .../build/_deps/fmt-src/test/os-test.cc | 547 + .../build/_deps/fmt-src/test/ostream-test.cc | 322 + .../build/_deps/fmt-src/test/posix-mock-test.cc | 459 + .../build/_deps/fmt-src/test/posix-mock.h | 77 + .../build/_deps/fmt-src/test/printf-test.cc | 584 + .../build/_deps/fmt-src/test/ranges-odr-test.cc | 17 + .../build/_deps/fmt-src/test/ranges-test.cc | 424 + .../build/_deps/fmt-src/test/scan-test.cc | 116 + .../smart_pointers/build/_deps/fmt-src/test/scan.h | 241 + .../fmt-src/test/static-export-test/CMakeLists.txt | 30 + .../fmt-src/test/static-export-test/library.cc | 5 + .../_deps/fmt-src/test/static-export-test/main.cc | 6 + .../build/_deps/fmt-src/test/std-test.cc | 79 + .../build/_deps/fmt-src/test/test-assert.h | 39 + .../build/_deps/fmt-src/test/test-main.cc | 43 + .../build/_deps/fmt-src/test/unicode-test.cc | 48 + .../build/_deps/fmt-src/test/util.cc | 46 + .../smart_pointers/build/_deps/fmt-src/test/util.h | 85 + .../build/_deps/fmt-src/test/xchar-test.cc | 521 + 62 files changed, 50466 insertions(+) create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/main.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/args-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/assert-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/chrono-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/color-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-error-test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-fp-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/core-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/cuda-test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/cuda-test/cpp14.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/cuda-test/cuda-cpp14.cu create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/detect-stdfs.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/enforce-checks-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/find-package-test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/find-package-test/main.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/format-impl-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/format-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/README.md create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/build.sh create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/chrono-duration.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/chrono-timepoint.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/float.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/fuzzer-common.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/main.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/named-arg.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/one-arg.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/fuzzing/two-args.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest-extra-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest-extra.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest-extra.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest/gmock-gtest-all.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest/gmock/gmock.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest/gtest/gtest-spi.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/gtest/gtest/gtest.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/header-only-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/mock-allocator.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/module-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/noexception-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/os-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/ostream-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/posix-mock-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/posix-mock.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/printf-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/ranges-odr-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/ranges-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/scan-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/scan.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/static-export-test/CMakeLists.txt create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/static-export-test/library.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/static-export-test/main.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/std-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/test-assert.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/test-main.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/unicode-test.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/util.cc create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/util.h create mode 100644 Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/xchar-test.cc (limited to 'Homework/cs3460/smart_pointers/build/_deps/fmt-src/test') diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/CMakeLists.txt b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/CMakeLists.txt new file mode 100644 index 0000000..9716378 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/CMakeLists.txt @@ -0,0 +1,245 @@ +add_subdirectory(gtest) + +set(TEST_MAIN_SRC test-main.cc gtest-extra.cc gtest-extra.h util.cc) +add_library(test-main STATIC ${TEST_MAIN_SRC}) +target_include_directories(test-main PUBLIC + $) +target_link_libraries(test-main gtest fmt) + +function(add_fmt_executable name) + add_executable(${name} ${ARGN}) + # (Wstringop-overflow) - [meta-bug] bogus/missing -Wstringop-overflow warnings + # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=88443 + # Bogus -Wstringop-overflow warning + # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=100395 + # [10 Regression] spurious -Wstringop-overflow writing to a trailing array plus offset + # https://gcc.gnu.org/bugzilla/show_bug.cgi?id=95353 + if (CMAKE_CXX_COMPILER_ID MATCHES "GNU" AND + NOT CMAKE_CXX_COMPILER_VERSION VERSION_LESS 7.0) + target_compile_options(${name} PRIVATE -Wno-stringop-overflow) + # The linker flag is needed for LTO. + target_link_libraries(${name} -Wno-stringop-overflow) + endif () +endfunction() + +# Adds a test. +# Usage: add_fmt_test(name srcs...) +function(add_fmt_test name) + cmake_parse_arguments(ADD_FMT_TEST "HEADER_ONLY;MODULE" "" "" ${ARGN}) + + set(sources ${name}.cc ${ADD_FMT_TEST_UNPARSED_ARGUMENTS}) + if (ADD_FMT_TEST_HEADER_ONLY) + set(sources ${sources} ${TEST_MAIN_SRC} ../src/os.cc) + set(libs gtest fmt-header-only) + if (CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(PEDANTIC_COMPILE_FLAGS ${PEDANTIC_COMPILE_FLAGS} -Wno-weak-vtables) + endif () + elseif (ADD_FMT_TEST_MODULE) + set(libs gtest test-module) + set_source_files_properties(${name}.cc PROPERTIES OBJECT_DEPENDS test-module) + else () + set(libs test-main fmt) + endif () + add_fmt_executable(${name} ${sources}) + target_link_libraries(${name} ${libs}) + + # Define if certain C++ features can be used. + if (FMT_PEDANTIC) + target_compile_options(${name} PRIVATE ${PEDANTIC_COMPILE_FLAGS}) + endif () + if (FMT_WERROR) + target_compile_options(${name} PRIVATE ${WERROR_FLAG}) + endif () + add_test(NAME ${name} COMMAND ${name}) +endfunction() + +add_fmt_test(args-test) +add_fmt_test(assert-test) +add_fmt_test(chrono-test) +add_fmt_test(color-test) +add_fmt_test(core-test) +add_fmt_test(gtest-extra-test) +add_fmt_test(format-test mock-allocator.h) +if (MSVC) + target_compile_options(format-test PRIVATE /bigobj) +endif () +if (NOT (MSVC AND BUILD_SHARED_LIBS)) + add_fmt_test(format-impl-test HEADER_ONLY header-only-test.cc) +endif () +add_fmt_test(ostream-test) +add_fmt_test(compile-test) +add_fmt_test(compile-fp-test HEADER_ONLY) +if (MSVC) + # Without this option, MSVC returns 199711L for the __cplusplus macro. + target_compile_options(compile-fp-test PRIVATE /Zc:__cplusplus) +endif() +add_fmt_test(printf-test) +add_fmt_test(ranges-test ranges-odr-test.cc) +add_fmt_test(scan-test) +add_fmt_test(std-test) +try_compile(compile_result_unused + ${CMAKE_CURRENT_BINARY_DIR} + SOURCES ${CMAKE_CURRENT_LIST_DIR}/detect-stdfs.cc + OUTPUT_VARIABLE RAWOUTPUT) +string(REGEX REPLACE ".*libfound \"([^\"]*)\".*" "\\1" STDLIBFS "${RAWOUTPUT}") +if (STDLIBFS) + target_link_libraries(std-test ${STDLIBFS}) +endif () +add_fmt_test(unicode-test HEADER_ONLY) +if (MSVC) + target_compile_options(unicode-test PRIVATE /utf-8) +endif () +add_fmt_test(xchar-test) +add_fmt_test(enforce-checks-test) +target_compile_definitions(enforce-checks-test PRIVATE + -DFMT_ENFORCE_COMPILE_STRING) + +if (FMT_CAN_MODULE) + # The tests need {fmt} to be compiled as traditional library + # because of visibility of implementation details. + # If module support is present the module tests require a + # test-only module to be built from {fmt} + add_library(test-module OBJECT ${CMAKE_SOURCE_DIR}/src/fmt.cc) + target_compile_features(test-module PUBLIC ${FMT_REQUIRED_FEATURES}) + target_include_directories(test-module PUBLIC + $) + enable_module(test-module) + + add_fmt_test(module-test MODULE test-main.cc) + if (MSVC) + target_compile_options(test-module PRIVATE /utf-8 /Zc:__cplusplus + /Zc:externConstexpr /Zc:inline) + target_compile_options(module-test PRIVATE /utf-8 /Zc:__cplusplus + /Zc:externConstexpr /Zc:inline) + endif () +endif () + +if (NOT DEFINED MSVC_STATIC_RUNTIME AND MSVC) + foreach (flag_var + CMAKE_CXX_FLAGS CMAKE_CXX_FLAGS_DEBUG CMAKE_CXX_FLAGS_RELEASE + CMAKE_CXX_FLAGS_MINSIZEREL CMAKE_CXX_FLAGS_RELWITHDEBINFO) + if (${flag_var} MATCHES "^(/|-)(MT|MTd)") + set(MSVC_STATIC_RUNTIME ON) + break() + endif() + endforeach() +endif() + +if (NOT MSVC_STATIC_RUNTIME) + add_fmt_executable(posix-mock-test + posix-mock-test.cc ../src/format.cc ${TEST_MAIN_SRC}) + target_include_directories( + posix-mock-test PRIVATE ${PROJECT_SOURCE_DIR}/include) + target_link_libraries(posix-mock-test gtest) + if (FMT_PEDANTIC) + target_compile_options(posix-mock-test PRIVATE ${PEDANTIC_COMPILE_FLAGS}) + endif () + add_test(NAME posix-mock-test COMMAND posix-mock-test) + add_fmt_test(os-test) +endif () + +message(STATUS "FMT_PEDANTIC: ${FMT_PEDANTIC}") + +if (FMT_PEDANTIC) + # Test that the library can be compiled with exceptions disabled. + # -fno-exception is broken in icc: https://github.com/fmtlib/fmt/issues/822. + if (NOT CMAKE_CXX_COMPILER_ID STREQUAL "Intel") + check_cxx_compiler_flag(-fno-exceptions HAVE_FNO_EXCEPTIONS_FLAG) + endif () + if (HAVE_FNO_EXCEPTIONS_FLAG) + add_library(noexception-test ../src/format.cc noexception-test.cc) + target_include_directories( + noexception-test PRIVATE ${PROJECT_SOURCE_DIR}/include) + target_compile_options(noexception-test PRIVATE -fno-exceptions) + target_compile_options(noexception-test PRIVATE ${PEDANTIC_COMPILE_FLAGS}) + endif () + + # Test that the library compiles without locale. + add_library(nolocale-test ../src/format.cc) + target_include_directories( + nolocale-test PRIVATE ${PROJECT_SOURCE_DIR}/include) + target_compile_definitions( + nolocale-test PRIVATE FMT_STATIC_THOUSANDS_SEPARATOR=1) +endif () + +# These tests are disabled on Windows because they take too long. +if (FMT_PEDANTIC AND NOT WIN32) + # Test if incorrect API usages produce compilation error. + add_test(compile-error-test ${CMAKE_CTEST_COMMAND} + --build-and-test + "${CMAKE_CURRENT_SOURCE_DIR}/compile-error-test" + "${CMAKE_CURRENT_BINARY_DIR}/compile-error-test" + --build-generator ${CMAKE_GENERATOR} + --build-makeprogram ${CMAKE_MAKE_PROGRAM} + --build-options + "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" + "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}" + "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}" + "-DCXX_STANDARD_FLAG=${CXX_STANDARD_FLAG}" + "-DFMT_DIR=${CMAKE_SOURCE_DIR}") + + # Test if the targets are found from the build directory. + add_test(find-package-test ${CMAKE_CTEST_COMMAND} + -C ${CMAKE_BUILD_TYPE} + --build-and-test + "${CMAKE_CURRENT_SOURCE_DIR}/find-package-test" + "${CMAKE_CURRENT_BINARY_DIR}/find-package-test" + --build-generator ${CMAKE_GENERATOR} + --build-makeprogram ${CMAKE_MAKE_PROGRAM} + --build-options + "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" + "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}" + "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}" + "-DFMT_DIR=${PROJECT_BINARY_DIR}" + "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}" + "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}") + + # Test if the targets are found when add_subdirectory is used. + add_test(add-subdirectory-test ${CMAKE_CTEST_COMMAND} + -C ${CMAKE_BUILD_TYPE} + --build-and-test + "${CMAKE_CURRENT_SOURCE_DIR}/add-subdirectory-test" + "${CMAKE_CURRENT_BINARY_DIR}/add-subdirectory-test" + --build-generator ${CMAKE_GENERATOR} + --build-makeprogram ${CMAKE_MAKE_PROGRAM} + --build-options + "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" + "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}" + "-DPEDANTIC_COMPILE_FLAGS=${PEDANTIC_COMPILE_FLAGS}" + "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}") +endif () + +# This test are disabled on Windows because it is only *NIX issue. +if (FMT_PEDANTIC AND NOT WIN32) + add_test(static-export-test ${CMAKE_CTEST_COMMAND} + -C ${CMAKE_BUILD_TYPE} + --build-and-test + "${CMAKE_CURRENT_SOURCE_DIR}/static-export-test" + "${CMAKE_CURRENT_BINARY_DIR}/static-export-test" + --build-generator ${CMAKE_GENERATOR} + --build-makeprogram ${CMAKE_MAKE_PROGRAM} + --build-options + "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" + "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}" + "-DCMAKE_BUILD_TYPE=${CMAKE_BUILD_TYPE}") +endif () + +# Activate optional CUDA tests if CUDA is found. For version selection see +# https://docs.nvidia.com/cuda/cuda-c-programming-guide/index.html#cpp14-language-features +if (FMT_CUDA_TEST) + if (${CMAKE_VERSION} VERSION_LESS 3.15) + find_package(CUDA 9.0) + else () + include(CheckLanguage) + check_language(CUDA) + if (CMAKE_CUDA_COMPILER) + enable_language(CUDA OPTIONAL) + set(CUDA_FOUND TRUE) + endif () + endif () + + if (CUDA_FOUND) + add_subdirectory(cuda-test) + add_test(NAME cuda-test COMMAND fmt-in-cuda-test) + endif () +endif () diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt new file mode 100644 index 0000000..e08d0cf --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/CMakeLists.txt @@ -0,0 +1,17 @@ +cmake_minimum_required(VERSION 3.1...3.18) + +project(fmt-test CXX) + +add_subdirectory(../.. fmt) + +add_executable(library-test main.cc) +target_include_directories(library-test PUBLIC SYSTEM .) +target_compile_options(library-test PRIVATE ${PEDANTIC_COMPILE_FLAGS}) +target_link_libraries(library-test fmt::fmt) + +if (TARGET fmt::fmt-header-only) + add_executable(header-only-test main.cc) + target_include_directories(header-only-test PUBLIC SYSTEM .) + target_compile_options(header-only-test PRIVATE ${PEDANTIC_COMPILE_FLAGS}) + target_link_libraries(header-only-test fmt::fmt-header-only) +endif () diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/main.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/main.cc new file mode 100644 index 0000000..fcdf232 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/add-subdirectory-test/main.cc @@ -0,0 +1,5 @@ +#include "fmt/core.h" + +int main(int argc, char** argv) { + for (int i = 0; i < argc; ++i) fmt::print("{}: {}\n", i, argv[i]); +} diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/args-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/args-test.cc new file mode 100644 index 0000000..aa01fa4 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/args-test.cc @@ -0,0 +1,186 @@ +// Formatting library for C++ - dynamic argument store tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/args.h" + +#include + +#include "gtest/gtest.h" + +TEST(args_test, basic) { + fmt::dynamic_format_arg_store store; + store.push_back(42); + store.push_back("abc1"); + store.push_back(1.5f); + EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store)); +} + +TEST(args_test, strings_and_refs) { + // Unfortunately the tests are compiled with old ABI so strings use COW. + fmt::dynamic_format_arg_store store; + char str[] = "1234567890"; + store.push_back(str); + store.push_back(std::cref(str)); + store.push_back(fmt::string_view{str}); + str[0] = 'X'; + + auto result = fmt::vformat("{} and {} and {}", store); + EXPECT_EQ("1234567890 and X234567890 and X234567890", result); +} + +struct custom_type { + int i = 0; +}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter { + auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + auto format(const custom_type& p, FormatContext& ctx) -> decltype(ctx.out()) { + return format_to(ctx.out(), "cust={}", p.i); + } +}; +FMT_END_NAMESPACE + +TEST(args_test, custom_format) { + fmt::dynamic_format_arg_store store; + auto c = custom_type(); + store.push_back(c); + ++c.i; + store.push_back(c); + ++c.i; + store.push_back(std::cref(c)); + ++c.i; + auto result = fmt::vformat("{} and {} and {}", store); + EXPECT_EQ("cust=0 and cust=1 and cust=3", result); +} + +struct to_stringable { + friend fmt::string_view to_string_view(to_stringable) { return {}; } +}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter { + auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) { + return ctx.begin(); + } + + auto format(to_stringable, format_context& ctx) -> decltype(ctx.out()) { + return ctx.out(); + } +}; +FMT_END_NAMESPACE + +TEST(args_test, to_string_and_formatter) { + fmt::dynamic_format_arg_store store; + auto s = to_stringable(); + store.push_back(s); + store.push_back(std::cref(s)); + fmt::vformat("", store); +} + +TEST(args_test, named_int) { + fmt::dynamic_format_arg_store store; + store.push_back(fmt::arg("a1", 42)); + EXPECT_EQ("42", fmt::vformat("{a1}", store)); +} + +TEST(args_test, named_strings) { + fmt::dynamic_format_arg_store store; + char str[] = "1234567890"; + store.push_back(fmt::arg("a1", str)); + store.push_back(fmt::arg("a2", std::cref(str))); + str[0] = 'X'; + EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store)); +} + +TEST(args_test, named_arg_by_ref) { + fmt::dynamic_format_arg_store store; + char band[] = "Rolling Stones"; + store.push_back(fmt::arg("band", std::cref(band))); + band[9] = 'c'; // Changing band affects the output. + EXPECT_EQ(fmt::vformat("{band}", store), "Rolling Scones"); +} + +TEST(args_test, named_custom_format) { + fmt::dynamic_format_arg_store store; + auto c = custom_type(); + store.push_back(fmt::arg("c1", c)); + ++c.i; + store.push_back(fmt::arg("c2", c)); + ++c.i; + store.push_back(fmt::arg("c_ref", std::cref(c))); + ++c.i; + auto result = fmt::vformat("{c1} and {c2} and {c_ref}", store); + EXPECT_EQ("cust=0 and cust=1 and cust=3", result); +} + +TEST(args_test, clear) { + fmt::dynamic_format_arg_store store; + store.push_back(42); + + auto result = fmt::vformat("{}", store); + EXPECT_EQ("42", result); + + store.push_back(43); + result = fmt::vformat("{} and {}", store); + EXPECT_EQ("42 and 43", result); + + store.clear(); + store.push_back(44); + result = fmt::vformat("{}", store); + EXPECT_EQ("44", result); +} + +TEST(args_test, reserve) { + fmt::dynamic_format_arg_store store; + store.reserve(2, 1); + store.push_back(1.5f); + store.push_back(fmt::arg("a1", 42)); + auto result = fmt::vformat("{a1} and {}", store); + EXPECT_EQ("42 and 1.5", result); +} + +struct copy_throwable { + copy_throwable() {} + copy_throwable(const copy_throwable&) { throw "deal with it"; } +}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter { + auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) { + return ctx.begin(); + } + auto format(copy_throwable, format_context& ctx) -> decltype(ctx.out()) { + return ctx.out(); + } +}; +FMT_END_NAMESPACE + +TEST(args_test, throw_on_copy) { + fmt::dynamic_format_arg_store store; + store.push_back(std::string("foo")); + try { + store.push_back(copy_throwable()); + } catch (...) { + } + EXPECT_EQ(fmt::vformat("{}", store), "foo"); +} + +TEST(args_test, move_constructor) { + using store_type = fmt::dynamic_format_arg_store; + auto store = std::unique_ptr(new store_type()); + store->push_back(42); + store->push_back(std::string("foo")); + store->push_back(fmt::arg("a1", "foo")); + auto moved_store = std::move(*store); + store.reset(); + EXPECT_EQ(fmt::vformat("{} {} {a1}", moved_store), "42 foo foo"); +} diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/assert-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/assert-test.cc new file mode 100644 index 0000000..c74e617 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/assert-test.cc @@ -0,0 +1,31 @@ +// Formatting library for C++ - FMT_ASSERT test +// +// It is a separate test to minimize the number of EXPECT_DEBUG_DEATH checks +// which are slow on some platforms. In other tests FMT_ASSERT is made to throw +// an exception which is much faster and easier to check. +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/core.h" +#include "gtest/gtest.h" + +TEST(assert_test, fail) { +#if GTEST_HAS_DEATH_TEST + EXPECT_DEBUG_DEATH(FMT_ASSERT(false, "don't panic!"), "don't panic!"); +#else + fmt::print("warning: death tests are not supported\n"); +#endif +} + +TEST(assert_test, dangling_else) { + bool test_condition = false; + bool executed_else = false; + if (test_condition) + FMT_ASSERT(true, ""); + else + executed_else = true; + EXPECT_TRUE(executed_else); +} diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/chrono-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/chrono-test.cc new file mode 100644 index 0000000..0f2a249 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/chrono-test.cc @@ -0,0 +1,643 @@ +// Formatting library for C++ - time formatting tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/chrono.h" + +#include +#include + +#include "gtest-extra.h" // EXPECT_THROW_MSG +#include "util.h" // get_locale + +using fmt::runtime; + +using testing::Contains; + +auto make_tm() -> std::tm { + auto time = std::tm(); + time.tm_mday = 1; + return time; +} + +auto make_hour(int h) -> std::tm { + auto time = make_tm(); + time.tm_hour = h; + return time; +} + +auto make_minute(int m) -> std::tm { + auto time = make_tm(); + time.tm_min = m; + return time; +} + +auto make_second(int s) -> std::tm { + auto time = make_tm(); + time.tm_sec = s; + return time; +} + +std::string system_strftime(const std::string& format, const std::tm* timeptr, + std::locale* locptr = nullptr) { + auto loc = locptr ? *locptr : std::locale::classic(); + auto& facet = std::use_facet>(loc); + std::ostringstream os; + os.imbue(loc); + facet.put(os, os, ' ', timeptr, format.c_str(), + format.c_str() + format.size()); +#ifdef _WIN32 + // Workaround a bug in older versions of Universal CRT. + auto str = os.str(); + if (str == "-0000") str = "+0000"; + return str; +#else + return os.str(); +#endif +} + +FMT_CONSTEXPR std::tm make_tm(int year, int mon, int mday, int hour, int min, + int sec) { + auto tm = std::tm(); + tm.tm_sec = sec; + tm.tm_min = min; + tm.tm_hour = hour; + tm.tm_mday = mday; + tm.tm_mon = mon - 1; + tm.tm_year = year - 1900; + return tm; +} + +TEST(chrono_test, format_tm) { + auto tm = std::tm(); + tm.tm_year = 116; + tm.tm_mon = 3; + tm.tm_mday = 25; + tm.tm_hour = 11; + tm.tm_min = 22; + tm.tm_sec = 33; + EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), + "The date is 2016-04-25 11:22:33."); + EXPECT_EQ(fmt::format("{:%Y}", tm), "2016"); + EXPECT_EQ(fmt::format("{:%C}", tm), "20"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); + EXPECT_EQ(fmt::format("{:%e}", tm), "25"); + EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/16"); + EXPECT_EQ(fmt::format("{:%F}", tm), "2016-04-25"); + EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); + + // Short year + tm.tm_year = 999 - 1900; + tm.tm_mon = 0; // for %G + tm.tm_mday = 2; // for %G + tm.tm_wday = 3; // for %G + tm.tm_yday = 1; // for %G + EXPECT_EQ(fmt::format("{:%Y}", tm), "0999"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), "0999"); + EXPECT_EQ(fmt::format("{:%G}", tm), "0999"); + + tm.tm_year = 27 - 1900; + EXPECT_EQ(fmt::format("{:%Y}", tm), "0027"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), "0027"); + + // Overflow year + tm.tm_year = 2147483647; + EXPECT_EQ(fmt::format("{:%Y}", tm), "2147485547"); + + tm.tm_year = -2147483648; + EXPECT_EQ(fmt::format("{:%Y}", tm), "-2147481748"); + + // for week on the year + // https://www.cl.cam.ac.uk/~mgk25/iso-time.html + std::vector tm_list = { + make_tm(1975, 12, 29, 12, 14, 16), // W01 + make_tm(1977, 1, 2, 12, 14, 16), // W53 + make_tm(1999, 12, 27, 12, 14, 16), // W52 + make_tm(1999, 12, 31, 12, 14, 16), // W52 + make_tm(2000, 1, 1, 12, 14, 16), // W52 + make_tm(2000, 1, 2, 12, 14, 16), // W52 + make_tm(2000, 1, 3, 12, 14, 16) // W1 + }; + +#if defined(__MINGW32__) && !defined(_UCRT) + GTEST_SKIP() << "Skip the rest of this test because it relies on strftime() " + "conforming to C99, but on this platform, MINGW + MSVCRT, " + "the function conforms only to C89."; +#endif + + const std::string iso_week_spec = "%Y-%m-%d: %G %g %V"; + for (auto ctm : tm_list) { + // Calculate tm_yday, tm_wday, etc. + std::time_t t = std::mktime(&ctm); + tm = *std::localtime(&t); + + auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec); + EXPECT_EQ(system_strftime(iso_week_spec, &tm), + fmt::format(fmt::runtime(fmt_spec), tm)); + } + + // Every day from 1970-01-01 + std::time_t time_now = std::time(nullptr); + for (std::time_t t = 6 * 3600; t < time_now; t += 86400) { + tm = *std::localtime(&t); + + auto fmt_spec = fmt::format("{{:{}}}", iso_week_spec); + EXPECT_EQ(system_strftime(iso_week_spec, &tm), + fmt::format(fmt::runtime(fmt_spec), tm)); + } +} + +// MSVC: +// minkernel\crts\ucrt\src\appcrt\time\wcsftime.cpp(971) : Assertion failed: +// timeptr->tm_year >= -1900 && timeptr->tm_year <= 8099 +#ifndef _WIN32 +TEST(chrono_test, format_tm_future) { + auto tm = std::tm(); + tm.tm_year = 10445; // 10000+ years + tm.tm_mon = 3; + tm.tm_mday = 25; + tm.tm_hour = 11; + tm.tm_min = 22; + tm.tm_sec = 33; + EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), + "The date is 12345-04-25 11:22:33."); + EXPECT_EQ(fmt::format("{:%Y}", tm), "12345"); + EXPECT_EQ(fmt::format("{:%C}", tm), "123"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); + EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/45"); + EXPECT_EQ(fmt::format("{:%F}", tm), "12345-04-25"); + EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); +} + +TEST(chrono_test, format_tm_past) { + auto tm = std::tm(); + tm.tm_year = -2001; + tm.tm_mon = 3; + tm.tm_mday = 25; + tm.tm_hour = 11; + tm.tm_min = 22; + tm.tm_sec = 33; + EXPECT_EQ(fmt::format("The date is {:%Y-%m-%d %H:%M:%S}.", tm), + "The date is -101-04-25 11:22:33."); + EXPECT_EQ(fmt::format("{:%Y}", tm), "-101"); + + // macOS %C - "-1" + // Linux %C - "-2" + // fmt %C - "-1" + EXPECT_EQ(fmt::format("{:%C}", tm), "-1"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); + + // macOS %D - "04/25/01" (%y) + // Linux %D - "04/25/99" (%y) + // fmt %D - "04/25/01" (%y) + EXPECT_EQ(fmt::format("{:%D}", tm), "04/25/01"); + + EXPECT_EQ(fmt::format("{:%F}", tm), "-101-04-25"); + EXPECT_EQ(fmt::format("{:%T}", tm), "11:22:33"); + + tm.tm_year = -1901; // -1 + EXPECT_EQ(fmt::format("{:%Y}", tm), "-001"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); + + tm.tm_year = -1911; // -11 + EXPECT_EQ(fmt::format("{:%Y}", tm), "-011"); + EXPECT_EQ(fmt::format("{:%C%y}", tm), fmt::format("{:%Y}", tm)); +} +#endif + +TEST(chrono_test, grow_buffer) { + auto s = std::string("{:"); + for (int i = 0; i < 30; ++i) s += "%c"; + s += "}\n"; + auto t = std::time(nullptr); + (void)fmt::format(fmt::runtime(s), *std::localtime(&t)); +} + +TEST(chrono_test, format_to_empty_container) { + auto time = std::tm(); + time.tm_sec = 42; + auto s = std::string(); + fmt::format_to(std::back_inserter(s), "{:%S}", time); + EXPECT_EQ(s, "42"); +} + +TEST(chrono_test, empty_result) { EXPECT_EQ(fmt::format("{}", std::tm()), ""); } + +auto equal(const std::tm& lhs, const std::tm& rhs) -> bool { + return lhs.tm_sec == rhs.tm_sec && lhs.tm_min == rhs.tm_min && + lhs.tm_hour == rhs.tm_hour && lhs.tm_mday == rhs.tm_mday && + lhs.tm_mon == rhs.tm_mon && lhs.tm_year == rhs.tm_year && + lhs.tm_wday == rhs.tm_wday && lhs.tm_yday == rhs.tm_yday && + lhs.tm_isdst == rhs.tm_isdst; +} + +TEST(chrono_test, localtime) { + auto t = std::time(nullptr); + auto tm = *std::localtime(&t); + EXPECT_TRUE(equal(tm, fmt::localtime(t))); +} + +TEST(chrono_test, gmtime) { + auto t = std::time(nullptr); + auto tm = *std::gmtime(&t); + EXPECT_TRUE(equal(tm, fmt::gmtime(t))); +} + +template auto strftime_full(TimePoint tp) -> std::string { + auto t = std::chrono::system_clock::to_time_t(tp); + auto tm = *std::localtime(&t); + return system_strftime("%Y-%m-%d %H:%M:%S", &tm); +} + +TEST(chrono_test, time_point) { + auto t1 = std::chrono::system_clock::now(); + EXPECT_EQ(strftime_full(t1), fmt::format("{:%Y-%m-%d %H:%M:%S}", t1)); + EXPECT_EQ(strftime_full(t1), fmt::format("{}", t1)); + using time_point = + std::chrono::time_point; + auto t2 = time_point(std::chrono::seconds(42)); + EXPECT_EQ(strftime_full(t2), fmt::format("{:%Y-%m-%d %H:%M:%S}", t2)); + + std::vector spec_list = { + "%%", "%n", "%t", "%Y", "%EY", "%y", "%Oy", "%Ey", "%C", + "%EC", "%G", "%g", "%b", "%h", "%B", "%m", "%Om", "%U", + "%OU", "%W", "%OW", "%V", "%OV", "%j", "%d", "%Od", "%e", + "%Oe", "%a", "%A", "%w", "%Ow", "%u", "%Ou", "%H", "%OH", + "%I", "%OI", "%M", "%OM", "%S", "%OS", "%x", "%Ex", "%X", + "%EX", "%D", "%F", "%R", "%T", "%p", "%z", "%Z"}; +#ifndef _WIN32 + // Disabled on Windows because these formats are not consistent among + // platforms. + spec_list.insert(spec_list.end(), {"%c", "%Ec", "%r"}); +#elif defined(__MINGW32__) && !defined(_UCRT) + // Only C89 conversion specifiers when using MSVCRT instead of UCRT + spec_list = {"%%", "%Y", "%y", "%b", "%B", "%m", "%U", "%W", "%j", "%d", "%a", + "%A", "%w", "%H", "%I", "%M", "%S", "%x", "%X", "%p", "%Z"}; +#endif + spec_list.push_back("%Y-%m-%d %H:%M:%S"); + + for (const auto& spec : spec_list) { + auto t = std::chrono::system_clock::to_time_t(t1); + auto tm = *std::localtime(&t); + + auto sys_output = system_strftime(spec, &tm); + + auto fmt_spec = fmt::format("{{:{}}}", spec); + EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), t1)); + EXPECT_EQ(sys_output, fmt::format(fmt::runtime(fmt_spec), tm)); + } +} + +#ifndef FMT_STATIC_THOUSANDS_SEPARATOR + +TEST(chrono_test, format_default) { + EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42))); + EXPECT_EQ("42as", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42fs", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42ps", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42ns", fmt::format("{}", std::chrono::nanoseconds(42))); + EXPECT_EQ("42µs", fmt::format("{}", std::chrono::microseconds(42))); + EXPECT_EQ("42ms", fmt::format("{}", std::chrono::milliseconds(42))); + EXPECT_EQ("42cs", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42ds", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42s", fmt::format("{}", std::chrono::seconds(42))); + EXPECT_EQ("42das", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42hs", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42ks", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42Ms", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42Gs", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42Ts", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42Ps", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42Es", + fmt::format("{}", std::chrono::duration(42))); + EXPECT_EQ("42m", fmt::format("{}", std::chrono::minutes(42))); + EXPECT_EQ("42h", fmt::format("{}", std::chrono::hours(42))); + EXPECT_EQ( + "42[15]s", + fmt::format("{}", std::chrono::duration>(42))); + EXPECT_EQ( + "42[15/4]s", + fmt::format("{}", std::chrono::duration>(42))); +} + +TEST(chrono_test, align) { + auto s = std::chrono::seconds(42); + EXPECT_EQ("42s ", fmt::format("{:5}", s)); + EXPECT_EQ("42s ", fmt::format("{:{}}", s, 5)); + EXPECT_EQ(" 42s", fmt::format("{:>5}", s)); + EXPECT_EQ("**42s**", fmt::format("{:*^7}", s)); + EXPECT_EQ("03:25:45 ", + fmt::format("{:12%H:%M:%S}", std::chrono::seconds(12345))); + EXPECT_EQ(" 03:25:45", + fmt::format("{:>12%H:%M:%S}", std::chrono::seconds(12345))); + EXPECT_EQ("~~03:25:45~~", + fmt::format("{:~^12%H:%M:%S}", std::chrono::seconds(12345))); + EXPECT_EQ("03:25:45 ", + fmt::format("{:{}%H:%M:%S}", std::chrono::seconds(12345), 12)); +} + +TEST(chrono_test, format_specs) { + EXPECT_EQ("%", fmt::format("{:%%}", std::chrono::seconds(0))); + EXPECT_EQ("\n", fmt::format("{:%n}", std::chrono::seconds(0))); + EXPECT_EQ("\t", fmt::format("{:%t}", std::chrono::seconds(0))); + EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(0))); + EXPECT_EQ("00", fmt::format("{:%S}", std::chrono::seconds(60))); + EXPECT_EQ("42", fmt::format("{:%S}", std::chrono::seconds(42))); + EXPECT_EQ("01.234", fmt::format("{:%S}", std::chrono::milliseconds(1234))); + EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(0))); + EXPECT_EQ("00", fmt::format("{:%M}", std::chrono::minutes(60))); + EXPECT_EQ("42", fmt::format("{:%M}", std::chrono::minutes(42))); + EXPECT_EQ("01", fmt::format("{:%M}", std::chrono::seconds(61))); + EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(0))); + EXPECT_EQ("00", fmt::format("{:%H}", std::chrono::hours(24))); + EXPECT_EQ("14", fmt::format("{:%H}", std::chrono::hours(14))); + EXPECT_EQ("01", fmt::format("{:%H}", std::chrono::minutes(61))); + EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(0))); + EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(12))); + EXPECT_EQ("12", fmt::format("{:%I}", std::chrono::hours(24))); + EXPECT_EQ("04", fmt::format("{:%I}", std::chrono::hours(4))); + EXPECT_EQ("02", fmt::format("{:%I}", std::chrono::hours(14))); + EXPECT_EQ("03:25:45", + fmt::format("{:%H:%M:%S}", std::chrono::seconds(12345))); + EXPECT_EQ("03:25", fmt::format("{:%R}", std::chrono::seconds(12345))); + EXPECT_EQ("03:25:45", fmt::format("{:%T}", std::chrono::seconds(12345))); + EXPECT_EQ("12345", fmt::format("{:%Q}", std::chrono::seconds(12345))); + EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(12345))); +} + +TEST(chrono_test, invalid_specs) { + auto sec = std::chrono::seconds(0); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%a}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%A}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%c}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%x}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ex}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%X}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%EX}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%D}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%F}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Ec}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%w}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%u}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%b}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%B}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%z}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Z}"), sec), fmt::format_error, + "no date"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Eq}"), sec), fmt::format_error, + "invalid format"); + EXPECT_THROW_MSG((void)fmt::format(runtime("{:%Oq}"), sec), fmt::format_error, + "invalid format"); +} + +auto format_tm(const std::tm& time, fmt::string_view spec, + const std::locale& loc) -> std::string { + auto& facet = std::use_facet>(loc); + std::ostringstream os; + os.imbue(loc); + facet.put(os, os, ' ', &time, spec.begin(), spec.end()); + return os.str(); +} + +TEST(chrono_test, locale) { + auto loc = get_locale("ja_JP.utf8"); + if (loc == std::locale::classic()) return; +# define EXPECT_TIME(spec, time, duration) \ + { \ + auto jp_loc = std::locale("ja_JP.utf8"); \ + EXPECT_EQ(format_tm(time, spec, jp_loc), \ + fmt::format(jp_loc, "{:L" spec "}", duration)); \ + } + EXPECT_TIME("%OH", make_hour(14), std::chrono::hours(14)); + EXPECT_TIME("%OI", make_hour(14), std::chrono::hours(14)); + EXPECT_TIME("%OM", make_minute(42), std::chrono::minutes(42)); + EXPECT_TIME("%OS", make_second(42), std::chrono::seconds(42)); + auto time = make_tm(); + time.tm_hour = 3; + time.tm_min = 25; + time.tm_sec = 45; + auto sec = std::chrono::seconds(12345); + EXPECT_TIME("%r", time, sec); + EXPECT_TIME("%p", time, sec); +} + +using dms = std::chrono::duration; + +TEST(chrono_test, format_default_fp) { + typedef std::chrono::duration fs; + EXPECT_EQ("1.234s", fmt::format("{}", fs(1.234))); + typedef std::chrono::duration fms; + EXPECT_EQ("1.234ms", fmt::format("{}", fms(1.234))); + typedef std::chrono::duration ds; + EXPECT_EQ("1.234s", fmt::format("{}", ds(1.234))); + EXPECT_EQ("1.234ms", fmt::format("{}", dms(1.234))); +} + +TEST(chrono_test, format_precision) { + EXPECT_THROW_MSG( + (void)fmt::format(runtime("{:.2}"), std::chrono::seconds(42)), + fmt::format_error, "precision not allowed for this argument type"); + EXPECT_EQ("1ms", fmt::format("{:.0}", dms(1.234))); + EXPECT_EQ("1.2ms", fmt::format("{:.1}", dms(1.234))); + EXPECT_EQ("1.23ms", fmt::format("{:.{}}", dms(1.234), 2)); + + EXPECT_EQ("13ms", fmt::format("{:.0}", dms(12.56))); + EXPECT_EQ("12.6ms", fmt::format("{:.1}", dms(12.56))); + EXPECT_EQ("12.56ms", fmt::format("{:.2}", dms(12.56))); +} + +TEST(chrono_test, format_full_specs) { + EXPECT_EQ("1ms ", fmt::format("{:6.0}", dms(1.234))); + EXPECT_EQ("1.2ms ", fmt::format("{:6.1}", dms(1.234))); + EXPECT_EQ(" 1.23ms", fmt::format("{:>8.{}}", dms(1.234), 2)); + EXPECT_EQ(" 1.2ms ", fmt::format("{:^{}.{}}", dms(1.234), 7, 1)); + EXPECT_EQ(" 1.23ms ", fmt::format("{0:^{2}.{1}}", dms(1.234), 2, 8)); + EXPECT_EQ("=1.234ms=", fmt::format("{:=^{}.{}}", dms(1.234), 9, 3)); + EXPECT_EQ("*1.2340ms*", fmt::format("{:*^10.4}", dms(1.234))); + + EXPECT_EQ("13ms ", fmt::format("{:6.0}", dms(12.56))); + EXPECT_EQ(" 13ms", fmt::format("{:>8.{}}", dms(12.56), 0)); + EXPECT_EQ(" 13ms ", fmt::format("{:^{}.{}}", dms(12.56), 6, 0)); + EXPECT_EQ(" 13ms ", fmt::format("{0:^{2}.{1}}", dms(12.56), 0, 8)); + EXPECT_EQ("==13ms===", fmt::format("{:=^{}.{}}", dms(12.56), 9, 0)); + EXPECT_EQ("***13ms***", fmt::format("{:*^10.0}", dms(12.56))); +} + +TEST(chrono_test, format_simple_q) { + typedef std::chrono::duration fs; + EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", fs(1.234))); + typedef std::chrono::duration fms; + EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", fms(1.234))); + typedef std::chrono::duration ds; + EXPECT_EQ("1.234 s", fmt::format("{:%Q %q}", ds(1.234))); + EXPECT_EQ("1.234 ms", fmt::format("{:%Q %q}", dms(1.234))); +} + +TEST(chrono_test, format_precision_q) { + EXPECT_THROW_MSG( + (void)fmt::format(runtime("{:.2%Q %q}"), std::chrono::seconds(42)), + fmt::format_error, "precision not allowed for this argument type"); + EXPECT_EQ("1.2 ms", fmt::format("{:.1%Q %q}", dms(1.234))); + EXPECT_EQ("1.23 ms", fmt::format("{:.{}%Q %q}", dms(1.234), 2)); +} + +TEST(chrono_test, format_full_specs_q) { + EXPECT_EQ("1 ms ", fmt::format("{:7.0%Q %q}", dms(1.234))); + EXPECT_EQ("1.2 ms ", fmt::format("{:7.1%Q %q}", dms(1.234))); + EXPECT_EQ(" 1.23 ms", fmt::format("{:>8.{}%Q %q}", dms(1.234), 2)); + EXPECT_EQ(" 1.2 ms ", fmt::format("{:^{}.{}%Q %q}", dms(1.234), 8, 1)); + EXPECT_EQ(" 1.23 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(1.234), 2, 9)); + EXPECT_EQ("=1.234 ms=", fmt::format("{:=^{}.{}%Q %q}", dms(1.234), 10, 3)); + EXPECT_EQ("*1.2340 ms*", fmt::format("{:*^11.4%Q %q}", dms(1.234))); + + EXPECT_EQ("13 ms ", fmt::format("{:7.0%Q %q}", dms(12.56))); + EXPECT_EQ(" 13 ms", fmt::format("{:>8.{}%Q %q}", dms(12.56), 0)); + EXPECT_EQ(" 13 ms ", fmt::format("{:^{}.{}%Q %q}", dms(12.56), 8, 0)); + EXPECT_EQ(" 13 ms ", fmt::format("{0:^{2}.{1}%Q %q}", dms(12.56), 0, 9)); + EXPECT_EQ("==13 ms==", fmt::format("{:=^{}.{}%Q %q}", dms(12.56), 9, 0)); + EXPECT_EQ("***13 ms***", fmt::format("{:*^11.0%Q %q}", dms(12.56))); +} + +TEST(chrono_test, invalid_width_id) { + EXPECT_THROW((void)fmt::format(runtime("{:{o}"), std::chrono::seconds(0)), + fmt::format_error); +} + +TEST(chrono_test, invalid_colons) { + EXPECT_THROW((void)fmt::format(runtime("{0}=:{0::"), std::chrono::seconds(0)), + fmt::format_error); +} + +TEST(chrono_test, negative_durations) { + EXPECT_EQ("-12345", fmt::format("{:%Q}", std::chrono::seconds(-12345))); + EXPECT_EQ("-03:25:45", + fmt::format("{:%H:%M:%S}", std::chrono::seconds(-12345))); + EXPECT_EQ("-00:01", + fmt::format("{:%M:%S}", std::chrono::duration(-1))); + EXPECT_EQ("s", fmt::format("{:%q}", std::chrono::seconds(-12345))); + EXPECT_EQ("-00.127", + fmt::format("{:%S}", + std::chrono::duration{-127})); + auto min = std::numeric_limits::min(); + EXPECT_EQ(fmt::format("{}", min), + fmt::format("{:%Q}", std::chrono::duration(min))); +} + +TEST(chrono_test, special_durations) { + auto value = fmt::format("{:%S}", std::chrono::duration(1e20)); + EXPECT_EQ(value, "40"); + auto nan = std::numeric_limits::quiet_NaN(); + EXPECT_EQ( + "nan nan nan nan nan:nan nan", + fmt::format("{:%I %H %M %S %R %r}", std::chrono::duration(nan))); + EXPECT_EQ(fmt::format("{}", std::chrono::duration(1)), + "1Es"); + EXPECT_EQ(fmt::format("{}", std::chrono::duration(1)), + "1as"); + EXPECT_EQ(fmt::format("{:%R}", std::chrono::duration{2}), + "03:33"); + EXPECT_EQ(fmt::format("{:%T}", std::chrono::duration{2}), + "03:33:20"); + EXPECT_EQ("44.000000000000", + fmt::format("{:%S}", std::chrono::duration( + 1.54213895E+26))); +} + +TEST(chrono_test, unsigned_duration) { + EXPECT_EQ("42s", fmt::format("{}", std::chrono::duration(42))); +} + +TEST(chrono_test, weekday) { + auto loc = get_locale("ru_RU.UTF-8"); + std::locale::global(loc); + auto mon = fmt::weekday(1); + + auto tm = std::tm(); + tm.tm_wday = static_cast(mon.c_encoding()); + + EXPECT_EQ(fmt::format("{}", mon), "Mon"); + EXPECT_EQ(fmt::format("{:%a}", tm), "Mon"); + + if (loc != std::locale::classic()) { + EXPECT_THAT((std::vector{"пн", "Пн", "пнд", "Пнд"}), + Contains(fmt::format(loc, "{:L}", mon))); + EXPECT_THAT((std::vector{"пн", "Пн", "пнд", "Пнд"}), + Contains(fmt::format(loc, "{:%a}", tm))); + } +} + +TEST(chrono_test, cpp20_duration_subsecond_support) { + using attoseconds = std::chrono::duration; + // Check that 18 digits of subsecond precision are supported. + EXPECT_EQ(fmt::format("{:%S}", attoseconds{999999999999999999}), + "00.999999999999999999"); + EXPECT_EQ(fmt::format("{:%S}", attoseconds{673231113420148734}), + "00.673231113420148734"); + EXPECT_EQ(fmt::format("{:%S}", attoseconds{-673231113420148734}), + "-00.673231113420148734"); + EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{13420148734}), + "13.420148734"); + EXPECT_EQ(fmt::format("{:%S}", std::chrono::nanoseconds{-13420148734}), + "-13.420148734"); + EXPECT_EQ(fmt::format("{:%S}", std::chrono::milliseconds{1234}), "01.234"); + { + // Check that {:%H:%M:%S} is equivalent to {:%T}. + auto dur = std::chrono::milliseconds{3601234}; + auto formatted_dur = fmt::format("{:%T}", dur); + EXPECT_EQ(formatted_dur, "01:00:01.234"); + EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur); + } + using nanoseconds_dbl = std::chrono::duration; + EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{-123456789}), "-00.123456789"); + EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{9123456789}), "09.123456789"); + // Verify that only the seconds part is extracted and printed. + EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123456789}), "39.123456789"); + EXPECT_EQ(fmt::format("{:%S}", nanoseconds_dbl{99123000000}), "39.123000000"); + { + // Now the hour is printed, and we also test if negative doubles work. + auto dur = nanoseconds_dbl{-99123456789}; + auto formatted_dur = fmt::format("{:%T}", dur); + EXPECT_EQ(formatted_dur, "-00:01:39.123456789"); + EXPECT_EQ(fmt::format("{:%H:%M:%S}", dur), formatted_dur); + } + // Check that durations with precision greater than std::chrono::seconds have + // fixed precision, and print zeros even if there is no fractional part. + EXPECT_EQ(fmt::format("{:%S}", std::chrono::microseconds{7000000}), + "07.000000"); + EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration>(1)), + "00.333333"); + EXPECT_EQ(fmt::format("{:%S}", std::chrono::duration>(1)), + "00.142857"); +} + +#endif // FMT_STATIC_THOUSANDS_SEPARATOR diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/color-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/color-test.cc new file mode 100644 index 0000000..c2ba13a --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/color-test.cc @@ -0,0 +1,72 @@ +// Formatting library for C++ - color tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/color.h" + +#include // std::back_inserter + +#include "gtest-extra.h" // EXPECT_WRITE + +TEST(color_test, format) { + EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"), + "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m"); + EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"), + "\x1b[38;2;000;000;255mblue\x1b[0m"); + EXPECT_EQ( + fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"), + "\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"), "\x1b[1mbold\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::faint, "faint"), "\x1b[2mfaint\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"), + "\x1b[3mitalic\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"), + "\x1b[4munderline\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::blink, "blink"), "\x1b[5mblink\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::reverse, "reverse"), + "\x1b[7mreverse\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::conceal, "conceal"), + "\x1b[8mconceal\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"), + "\x1b[9mstrikethrough\x1b[0m"); + EXPECT_EQ( + fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"), + "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"), + "\x1b[1mbold error\x1b[0m"); + EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"), + "\x1b[38;2;000;000;255mblue log\x1b[0m"); + EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi"); + EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"), + "\x1b[31mtred\x1b[0m"); + EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"), + "\x1b[46mtcyan\x1b[0m"); + EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"), + "\x1b[92mtbgreen\x1b[0m"); + EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"), + "\x1b[105mtbmagenta\x1b[0m"); + EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "{}", "foo"), + "\x1b[31mfoo\x1b[0m"); + EXPECT_EQ(fmt::format("{}{}", fmt::styled("red", fg(fmt::color::red)), + fmt::styled("bold", fmt::emphasis::bold)), + "\x1b[38;2;255;000;000mred\x1b[0m\x1b[1mbold\x1b[0m"); + EXPECT_EQ(fmt::format("{}", fmt::styled("bar", fg(fmt::color::blue) | + fmt::emphasis::underline)), + "\x1b[4m\x1b[38;2;000;000;255mbar\x1b[0m"); +} + +TEST(color_test, format_to) { + auto out = std::string(); + fmt::format_to(std::back_inserter(out), fg(fmt::rgb(255, 20, 30)), + "rgb(255,20,30){}{}{}", 1, 2, 3); + EXPECT_EQ(fmt::to_string(out), + "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m"); +} + +TEST(color_test, print) { + EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"), + "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m"); +} diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-error-test/CMakeLists.txt b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-error-test/CMakeLists.txt new file mode 100644 index 0000000..9c65dfd --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-error-test/CMakeLists.txt @@ -0,0 +1,241 @@ +# Test if compile errors are produced where necessary. + +cmake_minimum_required(VERSION 3.1...3.18) +project(compile-error-test CXX) + +set(fmt_headers " + #include + #include + #include + #include +") + +set(error_test_names "") +set(non_error_test_content "") + +# For error tests (we expect them to produce compilation error): +# * adds a name of test into `error_test_names` list +# * generates a single source file (with the same name) for each test +# For non-error tests (we expect them to compile successfully): +# * adds a code segment as separate function to `non_error_test_content` +function (expect_compile name code_fragment) + cmake_parse_arguments(EXPECT_COMPILE "ERROR" "" "" ${ARGN}) + string(MAKE_C_IDENTIFIER "${name}" test_name) + + if (EXPECT_COMPILE_ERROR) + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/${test_name}.cc" " + ${fmt_headers} + void ${test_name}() { + ${code_fragment} + } + ") + set(error_test_names_copy "${error_test_names}") + list(APPEND error_test_names_copy "${test_name}") + set(error_test_names "${error_test_names_copy}" PARENT_SCOPE) + else() + set(non_error_test_content " + ${non_error_test_content} + void ${test_name}() { + ${code_fragment} + }" PARENT_SCOPE) + endif() +endfunction () + +# Generates a source file for non-error test with `non_error_test_content` and +# CMake project file with all error and single non-error test targets. +function (run_tests) + set(cmake_targets "") + foreach(test_name IN LISTS error_test_names) + set(cmake_targets " + ${cmake_targets} + add_library(test-${test_name} ${test_name}.cc) + target_link_libraries(test-${test_name} PRIVATE fmt::fmt) + ") + endforeach() + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/non_error_test.cc" " + ${fmt_headers} + ${non_error_test_content} + ") + set(cmake_targets " + ${cmake_targets} + add_library(non-error-test non_error_test.cc) + target_link_libraries(non-error-test PRIVATE fmt::fmt) + ") + + file(WRITE "${CMAKE_CURRENT_BINARY_DIR}/test/CMakeLists.txt" " + cmake_minimum_required(VERSION 3.1...3.18) + project(tests CXX) + add_subdirectory(${FMT_DIR} fmt) + ${cmake_targets} + ") + + set(build_directory "${CMAKE_CURRENT_BINARY_DIR}/test/build") + file(MAKE_DIRECTORY "${build_directory}") + execute_process( + COMMAND + "${CMAKE_COMMAND}" + "-DCMAKE_CXX_COMPILER=${CMAKE_CXX_COMPILER}" + "-DCMAKE_CXX_FLAGS=${CMAKE_CXX_FLAGS}" + "-DCMAKE_CXX_STANDARD=${CMAKE_CXX_STANDARD}" + "-DCMAKE_GENERATOR=${CMAKE_GENERATOR}" + "-DCMAKE_MAKE_PROGRAM=${CMAKE_MAKE_PROGRAM}" + "-DFMT_DIR=${FMT_DIR}" + "${CMAKE_CURRENT_BINARY_DIR}/test" + WORKING_DIRECTORY "${build_directory}" + RESULT_VARIABLE result_var + OUTPUT_VARIABLE output_var + ERROR_VARIABLE output_var) + if (NOT result_var EQUAL 0) + message(FATAL_ERROR "Unable to configure:\n${output_var}") + endif() + + foreach(test_name IN LISTS error_test_names) + execute_process( + COMMAND + "${CMAKE_COMMAND}" --build "${build_directory}" --target "test-${test_name}" + WORKING_DIRECTORY "${build_directory}" + RESULT_VARIABLE result_var + OUTPUT_VARIABLE output_var + ERROR_QUIET) + if (result_var EQUAL 0) + message(SEND_ERROR "No compile error for \"${test_name}\":\n${output_var}") + endif () + endforeach() + + execute_process( + COMMAND + "${CMAKE_COMMAND}" --build "${build_directory}" --target "non-error-test" + WORKING_DIRECTORY "${build_directory}" + RESULT_VARIABLE result_var + OUTPUT_VARIABLE output_var + ERROR_VARIABLE output_var) + if (NOT result_var EQUAL 0) + message(SEND_ERROR "Compile error for combined non-error test:\n${output_var}") + endif () +endfunction () + + +# check if the source file skeleton compiles +expect_compile(check "") +expect_compile(check-error "compilation_error" ERROR) + +# Formatting a wide character with a narrow format string is forbidden. +expect_compile(wide-character-narrow-format-string "fmt::format(L\"{}\", L'a');") +expect_compile(wide-character-narrow-format-string-error "fmt::format(\"{}\", L'a');" ERROR) + +# Formatting a wide string with a narrow format string is forbidden. +expect_compile(wide-string-narrow-format-string "fmt::format(L\"{}\", L\"foo\");") +expect_compile(wide-string-narrow-format-string-error "fmt::format(\"{}\", L\"foo\");" ERROR) + +# Formatting a narrow string with a wide format string is forbidden because +# mixing UTF-8 with UTF-16/32 can result in an invalid output. +expect_compile(narrow-string-wide-format-string "fmt::format(L\"{}\", L\"foo\");") +expect_compile(narrow-string-wide-format-string-error "fmt::format(L\"{}\", \"foo\");" ERROR) + +expect_compile(cast-to-string " + struct S { + operator std::string() const { return std::string(); } + }; + fmt::format(\"{}\", std::string(S())); +") +expect_compile(cast-to-string-error " + struct S { + operator std::string() const { return std::string(); } + }; + fmt::format(\"{}\", S()); +" ERROR) + +# Formatting a function +expect_compile(format-function " + void (*f)(); + fmt::format(\"{}\", fmt::ptr(f)); +") +expect_compile(format-function-error " + void (*f)(); + fmt::format(\"{}\", f); +" ERROR) + +# Formatting an unformattable argument should always be a compile time error +expect_compile(format-lots-of-arguments-with-unformattable " + struct E {}; + fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, E()); +" ERROR) +expect_compile(format-lots-of-arguments-with-function " + void (*f)(); + fmt::format(\"\", 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, f); +" ERROR) + +# Check if user-defined literals are available +include(CheckCXXSourceCompiles) +set(CMAKE_REQUIRED_FLAGS ${CXX_STANDARD_FLAG}) +check_cxx_source_compiles(" + void operator\"\" _udl(long double); + int main() {}" + SUPPORTS_USER_DEFINED_LITERALS) +set(CMAKE_REQUIRED_FLAGS ) +if (NOT SUPPORTS_USER_DEFINED_LITERALS) + set (SUPPORTS_USER_DEFINED_LITERALS OFF) +endif () + +# Make sure that compiler features detected in the header +# match the features detected in CMake. +if (SUPPORTS_USER_DEFINED_LITERALS) + set(supports_udl 1) +else () + set(supports_udl 0) +endif () +expect_compile(udl-check " + #if FMT_USE_USER_DEFINED_LITERALS != ${supports_udl} + # error + #endif +") + +if (CMAKE_CXX_STANDARD GREATER_EQUAL 20) + # Compile-time argument type check + expect_compile(format-string-number-spec " + #ifdef FMT_HAS_CONSTEVAL + fmt::format(\"{:d}\", 42); + #endif + ") + expect_compile(format-string-number-spec-error " + #ifdef FMT_HAS_CONSTEVAL + fmt::format(\"{:d}\", \"I am not a number\"); + #else + #error + #endif + " ERROR) + expect_compile(print-string-number-spec-error " + #ifdef FMT_HAS_CONSTEVAL + fmt::print(\"{:d}\", \"I am not a number\"); + #else + #error + #endif + " ERROR) + expect_compile(print-stream-string-number-spec-error " + #ifdef FMT_HAS_CONSTEVAL + fmt::print(std::cout, \"{:d}\", \"I am not a number\"); + #else + #error + #endif + " ERROR) + + # Compile-time argument name check + expect_compile(format-string-name " + #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS + using namespace fmt::literals; + fmt::print(\"{foo}\", \"foo\"_a=42); + #endif + ") + expect_compile(format-string-name-error " + #if defined(FMT_HAS_CONSTEVAL) && FMT_USE_NONTYPE_TEMPLATE_ARGS + using namespace fmt::literals; + fmt::print(\"{foo}\", \"bar\"_a=42); + #else + #error + #endif + " ERROR) +endif () + +# Run all tests +run_tests() diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-fp-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-fp-test.cc new file mode 100644 index 0000000..db0cd90 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-fp-test.cc @@ -0,0 +1,62 @@ +// Formatting library for C++ - formatting library tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/compile.h" +#include "gmock/gmock.h" + +#if defined(__cpp_lib_bit_cast) && __cpp_lib_bit_cast >= 201806 && \ + defined(__cpp_constexpr) && __cpp_constexpr >= 201907 && \ + defined(__cpp_constexpr_dynamic_alloc) && \ + __cpp_constexpr_dynamic_alloc >= 201907 && FMT_CPLUSPLUS >= 202002L +template struct test_string { + template constexpr bool operator==(const T& rhs) const noexcept { + return fmt::basic_string_view(rhs).compare(buffer) == 0; + } + Char buffer[max_string_length]{}; +}; + +template +consteval auto test_format(auto format, const Args&... args) { + test_string string{}; + fmt::format_to(string.buffer, format, args...); + return string; +} + +TEST(compile_time_formatting_test, floating_point) { + EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{}"), 0.0f)); + EXPECT_EQ("392.500000", test_format<11>(FMT_COMPILE("{0:f}"), 392.5f)); + + EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:}"), 0.0)); + EXPECT_EQ("0.000000", test_format<9>(FMT_COMPILE("{:f}"), 0.0)); + EXPECT_EQ("0", test_format<2>(FMT_COMPILE("{:g}"), 0.0)); + EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:}"), 392.65)); + EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:g}"), 392.65)); + EXPECT_EQ("392.65", test_format<7>(FMT_COMPILE("{:G}"), 392.65)); + EXPECT_EQ("4.9014e+06", test_format<11>(FMT_COMPILE("{:g}"), 4.9014e6)); + EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:f}"), -392.65)); + EXPECT_EQ("-392.650000", test_format<12>(FMT_COMPILE("{:F}"), -392.65)); + + EXPECT_EQ("3.926500e+02", test_format<13>(FMT_COMPILE("{0:e}"), 392.65)); + EXPECT_EQ("3.926500E+02", test_format<13>(FMT_COMPILE("{0:E}"), 392.65)); + EXPECT_EQ("+0000392.6", test_format<11>(FMT_COMPILE("{0:+010.4g}"), 392.65)); + EXPECT_EQ("9223372036854775808.000000", + test_format<27>(FMT_COMPILE("{:f}"), 9223372036854775807.0)); + + constexpr double nan = std::numeric_limits::quiet_NaN(); + EXPECT_EQ("nan", test_format<4>(FMT_COMPILE("{}"), nan)); + EXPECT_EQ("+nan", test_format<5>(FMT_COMPILE("{:+}"), nan)); + if (std::signbit(-nan)) + EXPECT_EQ("-nan", test_format<5>(FMT_COMPILE("{}"), -nan)); + else + fmt::print("Warning: compiler doesn't handle negative NaN correctly"); + + constexpr double inf = std::numeric_limits::infinity(); + EXPECT_EQ("inf", test_format<4>(FMT_COMPILE("{}"), inf)); + EXPECT_EQ("+inf", test_format<5>(FMT_COMPILE("{:+}"), inf)); + EXPECT_EQ("-inf", test_format<5>(FMT_COMPILE("{}"), -inf)); +} +#endif diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-test.cc new file mode 100644 index 0000000..005c499 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/compile-test.cc @@ -0,0 +1,392 @@ +// Formatting library for C++ - formatting library tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +#include "fmt/compile.h" + +#include + +#include "fmt/chrono.h" +#include "gmock/gmock.h" +#include "gtest-extra.h" + +TEST(iterator_test, counting_iterator) { + auto it = fmt::detail::counting_iterator(); + auto prev = it++; + EXPECT_EQ(prev.count(), 0); + EXPECT_EQ(it.count(), 1); + EXPECT_EQ((it + 41).count(), 42); +} + +TEST(iterator_test, truncating_iterator) { + char* p = nullptr; + auto it = fmt::detail::truncating_iterator(p, 3); + auto prev = it++; + EXPECT_EQ(prev.base(), p); + EXPECT_EQ(it.base(), p + 1); +} + +TEST(iterator_test, truncating_iterator_default_construct) { + auto it = fmt::detail::truncating_iterator(); + EXPECT_EQ(nullptr, it.base()); + EXPECT_EQ(std::size_t{0}, it.count()); +} + +#ifdef __cpp_lib_ranges +TEST(iterator_test, truncating_iterator_is_output_iterator) { + static_assert( + std::output_iterator, char>); +} +#endif + +TEST(iterator_test, truncating_back_inserter) { + auto buffer = std::string(); + auto bi = std::back_inserter(buffer); + auto it = fmt::detail::truncating_iterator(bi, 2); + *it++ = '4'; + *it++ = '2'; + *it++ = '1'; + EXPECT_EQ(buffer.size(), 2); + EXPECT_EQ(buffer, "42"); +} + +TEST(compile_test, compile_fallback) { + // FMT_COMPILE should fallback on runtime formatting when `if constexpr` is + // not available. + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42)); +} + +struct type_with_get { + template friend void get(type_with_get); +}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter : formatter { + template + auto format(type_with_get, FormatContext& ctx) -> decltype(ctx.out()) { + return formatter::format(42, ctx); + } +}; +FMT_END_NAMESPACE + +TEST(compile_test, compile_type_with_get) { + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), type_with_get())); +} + +#if defined(__cpp_if_constexpr) && defined(__cpp_return_type_deduction) +struct test_formattable {}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter : formatter { + char word_spec = 'f'; + constexpr auto parse(format_parse_context& ctx) { + auto it = ctx.begin(), end = ctx.end(); + if (it == end || *it == '}') return it; + if (it != end && (*it == 'f' || *it == 'b')) word_spec = *it++; + if (it != end && *it != '}') throw format_error("invalid format"); + return it; + } + template + constexpr auto format(test_formattable, FormatContext& ctx) const + -> decltype(ctx.out()) { + return formatter::format(word_spec == 'f' ? "foo" : "bar", + ctx); + } +}; +FMT_END_NAMESPACE + +TEST(compile_test, format_default) { + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42)); + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u)); + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll)); + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull)); + EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true)); + EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x')); + EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2)); + EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo")); + EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo"))); + EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable())); + auto t = std::chrono::system_clock::now(); + EXPECT_EQ(fmt::format("{}", t), fmt::format(FMT_COMPILE("{}"), t)); +# ifdef __cpp_lib_byte + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), std::byte{42})); +# endif +} + +TEST(compile_test, format_wide_string) { + EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42)); +} + +TEST(compile_test, format_specs) { + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42)); + EXPECT_EQ("1.2 ms ", + fmt::format(FMT_COMPILE("{:7.1%Q %q}"), + std::chrono::duration(1.234))); +} + +TEST(compile_test, dynamic_format_specs) { + EXPECT_EQ("foo ", fmt::format(FMT_COMPILE("{:{}}"), "foo", 5)); + EXPECT_EQ(" 3.14", fmt::format(FMT_COMPILE("{:{}.{}f}"), 3.141592, 6, 2)); + EXPECT_EQ( + "=1.234ms=", + fmt::format(FMT_COMPILE("{:=^{}.{}}"), + std::chrono::duration(1.234), 9, 3)); +} + +TEST(compile_test, manual_ordering) { + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{0}"), 42)); + EXPECT_EQ(" -42", fmt::format(FMT_COMPILE("{0:4}"), -42)); + EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {1}"), 41, 43)); + EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{1} {0}"), 43, 41)); + EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{0} {2}"), 41, 42, 43)); + EXPECT_EQ(" 41 43", fmt::format(FMT_COMPILE("{1:{2}} {0:4}"), 43, 41, 4)); + EXPECT_EQ("42 1.2 ms ", + fmt::format(FMT_COMPILE("{0} {1:7.1%Q %q}"), 42, + std::chrono::duration(1.234))); + EXPECT_EQ( + "true 42 42 foo 0x1234 foo", + fmt::format(FMT_COMPILE("{0} {1} {2} {3} {4} {5}"), true, 42, 42.0f, + "foo", reinterpret_cast(0x1234), test_formattable())); + EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{0}"), 42)); +} + +TEST(compile_test, named) { + auto runtime_named_field_compiled = + fmt::detail::compile(FMT_COMPILE("{arg}")); + static_assert(std::is_same_v>); + + EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), fmt::arg("arg", 42))); + EXPECT_EQ("41 43", fmt::format(FMT_COMPILE("{} {}"), fmt::arg("arg", 41), + fmt::arg("arg", 43))); + + EXPECT_EQ("foobar", + fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a0", "foo"), + fmt::arg("a1", "bar"))); + EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{}{a1}"), fmt::arg("a0", "foo"), + fmt::arg("a1", "bar"))); + EXPECT_EQ("foofoo", fmt::format(FMT_COMPILE("{a0}{}"), fmt::arg("a0", "foo"), + fmt::arg("a1", "bar"))); + EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{0}{a1}"), fmt::arg("a0", "foo"), + fmt::arg("a1", "bar"))); + EXPECT_EQ("foobar", fmt::format(FMT_COMPILE("{a0}{1}"), fmt::arg("a0", "foo"), + fmt::arg("a1", "bar"))); + + EXPECT_EQ("foobar", + fmt::format(FMT_COMPILE("{}{a1}"), "foo", fmt::arg("a1", "bar"))); + EXPECT_EQ("foobar", + fmt::format(FMT_COMPILE("{a0}{a1}"), fmt::arg("a1", "bar"), + fmt::arg("a2", "baz"), fmt::arg("a0", "foo"))); + EXPECT_EQ(" bar foo ", + fmt::format(FMT_COMPILE(" {foo} {bar} "), fmt::arg("foo", "bar"), + fmt::arg("bar", "foo"))); + + EXPECT_THROW(fmt::format(FMT_COMPILE("{invalid}"), fmt::arg("valid", 42)), + fmt::format_error); + +# if FMT_USE_NONTYPE_TEMPLATE_ARGS + using namespace fmt::literals; + auto statically_named_field_compiled = + fmt::detail::compile(FMT_COMPILE("{arg}")); + static_assert(std::is_same_v>); + + EXPECT_EQ("41 43", + fmt::format(FMT_COMPILE("{a0} {a1}"), "a0"_a = 41, "a1"_a = 43)); + EXPECT_EQ("41 43", + fmt::format(FMT_COMPILE("{a1} {a0}"), "a0"_a = 43, "a1"_a = 41)); +# endif +} + +TEST(compile_test, join) { + unsigned char data[] = {0x1, 0x2, 0xaf}; + EXPECT_EQ("0102af", fmt::format(FMT_COMPILE("{:02x}"), fmt::join(data, ""))); +} + +TEST(compile_test, format_to) { + char buf[8]; + auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42); + *end = '\0'; + EXPECT_STREQ("42", buf); + end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42); + *end = '\0'; + EXPECT_STREQ("2a", buf); +} + +TEST(compile_test, format_to_n) { + constexpr auto buffer_size = 8; + char buffer[buffer_size]; + auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42); + *res.out = '\0'; + EXPECT_STREQ("42", buffer); + res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42); + *res.out = '\0'; + EXPECT_STREQ("2a", buffer); +} + +#ifdef __cpp_lib_bit_cast +TEST(compile_test, constexpr_formatted_size) { + FMT_CONSTEXPR20 size_t s1 = fmt::formatted_size(FMT_COMPILE("{0}"), 42); + EXPECT_EQ(2, s1); + FMT_CONSTEXPR20 size_t s2 = fmt::formatted_size(FMT_COMPILE("{0:<4.2f}"), 42.0); + EXPECT_EQ(5, s2); +} +#endif + +TEST(compile_test, text_and_arg) { + EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42)); + EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42)); +} + +TEST(compile_test, unknown_format_fallback) { + EXPECT_EQ(" 42 ", + fmt::format(FMT_COMPILE("{name:^4}"), fmt::arg("name", 42))); + + std::vector v; + fmt::format_to(std::back_inserter(v), FMT_COMPILE("{name:^4}"), + fmt::arg("name", 42)); + EXPECT_EQ(" 42 ", fmt::string_view(v.data(), v.size())); + + char buffer[4]; + auto result = fmt::format_to_n(buffer, 4, FMT_COMPILE("{name:^5}"), + fmt::arg("name", 42)); + EXPECT_EQ(5u, result.size); + EXPECT_EQ(buffer + 4, result.out); + EXPECT_EQ(" 42 ", fmt::string_view(buffer, 4)); +} + +TEST(compile_test, empty) { EXPECT_EQ("", fmt::format(FMT_COMPILE(""))); } + +struct to_stringable { + friend fmt::string_view to_string_view(to_stringable) { return {}; } +}; + +FMT_BEGIN_NAMESPACE +template <> struct formatter { + auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) { + return ctx.begin(); + } + + template + auto format(const to_stringable&, FormatContext& ctx) -> decltype(ctx.out()) { + return ctx.out(); + } +}; +FMT_END_NAMESPACE + +TEST(compile_test, to_string_and_formatter) { + fmt::format(FMT_COMPILE("{}"), to_stringable()); +} + +TEST(compile_test, print) { + EXPECT_WRITE(stdout, fmt::print(FMT_COMPILE("Don't {}!"), "panic"), + "Don't panic!"); + EXPECT_WRITE(stderr, fmt::print(stderr, FMT_COMPILE("Don't {}!"), "panic"), + "Don't panic!"); +} +#endif + +#if FMT_USE_NONTYPE_TEMPLATE_ARGS +TEST(compile_test, compile_format_string_literal) { + using namespace fmt::literals; + EXPECT_EQ("", fmt::format(""_cf)); + EXPECT_EQ("42", fmt::format("{}"_cf, 42)); + EXPECT_EQ(L"42", fmt::format(L"{}"_cf, 42)); +} +#endif + +// MSVS 2019 19.29.30145.0 - Support C++20 and OK. +// MSVS 2022 19.32.31332.0 - compile-test.cc(362,3): fatal error C1001: Internal +// compiler error. +// (compiler file +// 'D:\a\_work\1\s\src\vctools\Compiler\CxxFE\sl\p1\c\constexpr\constexpr.cpp', +// line 8635) +#if ((FMT_CPLUSPLUS >= 202002L) && \ + (!FMT_MSC_VERSION || FMT_MSC_VERSION < 1930)) || \ + (FMT_CPLUSPLUS >= 201709L && FMT_GCC_VERSION >= 1002) +template struct test_string { + template constexpr bool operator==(const T& rhs) const noexcept { + return fmt::basic_string_view(rhs).compare(buffer) == 0; + } + Char buffer[max_string_length]{}; +}; + +template +consteval auto test_format(auto format, const Args&... args) { + test_string string{}; + fmt::format_to(string.buffer, format, args...); + return string; +} + +TEST(compile_time_formatting_test, bool) { + EXPECT_EQ("true", test_format<5>(FMT_COMPILE("{}"), true)); + EXPECT_EQ("false", test_format<6>(FMT_COMPILE("{}"), false)); + EXPECT_EQ("true ", test_format<6>(FMT_COMPILE("{:5}"), true)); + EXPECT_EQ("1", test_format<2>(FMT_COMPILE("{:d}"), true)); +} + +TEST(compile_time_formatting_test, integer) { + EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), 42)); + EXPECT_EQ("420", test_format<4>(FMT_COMPILE("{}"), 420)); + EXPECT_EQ("42 42", test_format<6>(FMT_COMPILE("{} {}"), 42, 42)); + EXPECT_EQ("42 42", + test_format<6>(FMT_COMPILE("{} {}"), uint32_t{42}, uint64_t{42})); + + EXPECT_EQ("+42", test_format<4>(FMT_COMPILE("{:+}"), 42)); + EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{:-}"), 42)); + EXPECT_EQ(" 42", test_format<4>(FMT_COMPILE("{: }"), 42)); + + EXPECT_EQ("-0042", test_format<6>(FMT_COMPILE("{:05}"), -42)); + + EXPECT_EQ("101010", test_format<7>(FMT_COMPILE("{:b}"), 42)); + EXPECT_EQ("0b101010", test_format<9>(FMT_COMPILE("{:#b}"), 42)); + EXPECT_EQ("0B101010", test_format<9>(FMT_COMPILE("{:#B}"), 42)); + EXPECT_EQ("042", test_format<4>(FMT_COMPILE("{:#o}"), 042)); + EXPECT_EQ("0x4a", test_format<5>(FMT_COMPILE("{:#x}"), 0x4a)); + EXPECT_EQ("0X4A", test_format<5>(FMT_COMPILE("{:#X}"), 0x4a)); + + EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42)); + EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ll)); + EXPECT_EQ(" 42", test_format<6>(FMT_COMPILE("{:5}"), 42ull)); + + EXPECT_EQ("42 ", test_format<5>(FMT_COMPILE("{:<4}"), 42)); + EXPECT_EQ(" 42", test_format<5>(FMT_COMPILE("{:>4}"), 42)); + EXPECT_EQ(" 42 ", test_format<5>(FMT_COMPILE("{:^4}"), 42)); + EXPECT_EQ("**-42", test_format<6>(FMT_COMPILE("{:*>5}"), -42)); +} + +TEST(compile_time_formatting_test, char) { + EXPECT_EQ("c", test_format<2>(FMT_COMPILE("{}"), 'c')); + + EXPECT_EQ("c ", test_format<4>(FMT_COMPILE("{:3}"), 'c')); + EXPECT_EQ("99", test_format<3>(FMT_COMPILE("{:d}"), 'c')); +} + +TEST(compile_time_formatting_test, string) { + EXPECT_EQ("42", test_format<3>(FMT_COMPILE("{}"), "42")); + EXPECT_EQ("The answer is 42", + test_format<17>(FMT_COMPILE("{} is {}"), "The answer", "42")); + + EXPECT_EQ("abc**", test_format<6>(FMT_COMPILE("{:*<5}"), "abc")); + EXPECT_EQ("**🤡**", test_format<9>(FMT_COMPILE("{:*^6}"), "🤡")); +} + +TEST(compile_time_formatting_test, combination) { + EXPECT_EQ("420, true, answer", + test_format<18>(FMT_COMPILE("{}, {}, {}"), 420, true, "answer")); + + EXPECT_EQ(" -42", test_format<5>(FMT_COMPILE("{:{}}"), -42, 4)); +} + +TEST(compile_time_formatting_test, custom_type) { + EXPECT_EQ("foo", test_format<4>(FMT_COMPILE("{}"), test_formattable())); + EXPECT_EQ("bar", test_format<4>(FMT_COMPILE("{:b}"), test_formattable())); +} + +TEST(compile_time_formatting_test, multibyte_fill) { + EXPECT_EQ("жж42", test_format<8>(FMT_COMPILE("{:ж>4}"), 42)); +} +#endif diff --git a/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/core-test.cc b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/core-test.cc new file mode 100644 index 0000000..c76dc16 --- /dev/null +++ b/Homework/cs3460/smart_pointers/build/_deps/fmt-src/test/core-test.cc @@ -0,0 +1,978 @@ +// Formatting library for C++ - core tests +// +// Copyright (c) 2012 - present, Victor Zverovich +// All rights reserved. +// +// For the license information refer to format.h. + +// clang-format off +#include "test-assert.h" +// clang-format on + +#define I 42 // simulate https://en.cppreference.com/w/c/numeric/complex/I +#include "fmt/core.h" +#undef I + +#include // std::copy_n +#include // INT_MAX +#include // std::strlen +#include // std::equal_to +#include // std::back_insert_iterator +#include // std::numeric_limits +#include // std::string +#include // std::is_same + +#include "gmock/gmock.h" + +using fmt::string_view; +using fmt::detail::buffer; + +using testing::_; +using testing::Invoke; +using testing::Return; + +#ifdef FMT_FORMAT_H_ +# error core-test includes format.h +#endif + +TEST(string_view_test, value_type) { + static_assert(std::is_same::value, ""); +} + +TEST(string_view_test, ctor) { + EXPECT_STREQ("abc", fmt::string_view("abc").data()); + EXPECT_EQ(3u, fmt::string_view("abc").size()); + + EXPECT_STREQ("defg", fmt::string_view(std::string("defg")).data()); + EXPECT_EQ(4u, fmt::string_view(std::string("defg")).size()); +} + +TEST(string_view_test, length) { + // Test that string_view::size() returns string length, not buffer size. + char str[100] = "some string"; + EXPECT_EQ(std::strlen(str), string_view(str).size()); + EXPECT_LT(std::strlen(str), sizeof(str)); +} + +// Check string_view's comparison operator. +template