diff options
Diffstat (limited to 'libcxx/test')
| -rw-r--r-- | libcxx/test/benchmarks/streams/fstream.bench.cpp (renamed from libcxx/test/benchmarks/streams/ofstream.bench.cpp) | 22 | ||||
| -rw-r--r-- | libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp | 2 | ||||
| -rw-r--r-- | libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp | 2 | ||||
| -rw-r--r-- | libcxx/test/libcxx/time/time.traits/is.clock.verify.cpp | 36 | ||||
| -rw-r--r-- | libcxx/test/std/time/time.traits/is.clock.compile.pass.cpp | 230 |
5 files changed, 288 insertions, 4 deletions
diff --git a/libcxx/test/benchmarks/streams/ofstream.bench.cpp b/libcxx/test/benchmarks/streams/fstream.bench.cpp index 60606a9..3ca1801 100644 --- a/libcxx/test/benchmarks/streams/ofstream.bench.cpp +++ b/libcxx/test/benchmarks/streams/fstream.bench.cpp @@ -11,7 +11,7 @@ #include <benchmark/benchmark.h> -static void bm_write(benchmark::State& state) { +static void bm_ofstream_write(benchmark::State& state) { std::vector<char> buffer; buffer.resize(16384); @@ -20,6 +20,24 @@ static void bm_write(benchmark::State& state) { for (auto _ : state) stream.write(buffer.data(), buffer.size()); } -BENCHMARK(bm_write); +BENCHMARK(bm_ofstream_write); + +static void bm_ifstream_read(benchmark::State& state) { + std::vector<char> buffer; + buffer.resize(16384); + + std::ofstream gen_testfile("testfile"); + gen_testfile.write(buffer.data(), buffer.size()); + + std::ifstream stream("testfile"); + assert(stream); + + for (auto _ : state) { + stream.read(buffer.data(), buffer.size()); + benchmark::DoNotOptimize(buffer); + stream.seekg(0); + } +} +BENCHMARK(bm_ifstream_read); BENCHMARK_MAIN(); diff --git a/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp b/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp index 283adbc..30e7b66 100644 --- a/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp +++ b/libcxx/test/libcxx/input.output/file.streams/fstreams/filebuf/traits_mismatch.verify.cpp @@ -19,4 +19,4 @@ std::basic_filebuf<char, std::char_traits<wchar_t> > f; // expected-error-re@*:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} -// expected-error@*:* 10 {{only virtual member functions can be marked 'override'}} +// expected-error@*:* 11 {{only virtual member functions can be marked 'override'}} diff --git a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp index ba6f3c3..daafb36 100644 --- a/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp +++ b/libcxx/test/libcxx/input.output/file.streams/fstreams/traits_mismatch.verify.cpp @@ -21,7 +21,7 @@ std::basic_fstream<char, std::char_traits<wchar_t> > f; // expected-error-re@*:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} // expected-error-re@*:* {{static assertion failed{{.*}}traits_type::char_type must be the same type as CharT}} -// expected-error@*:* 12 {{only virtual member functions can be marked 'override'}} +// expected-error@*:* 13 {{only virtual member functions can be marked 'override'}} // FIXME: As of commit r324062 Clang incorrectly generates a diagnostic about mismatching // exception specifications for types which are already invalid for one reason or another. diff --git a/libcxx/test/libcxx/time/time.traits/is.clock.verify.cpp b/libcxx/test/libcxx/time/time.traits/is.clock.verify.cpp new file mode 100644 index 0000000..f4f438d --- /dev/null +++ b/libcxx/test/libcxx/time/time.traits/is.clock.verify.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: std-at-least-c++20 + +// <chrono> +// +// template<class T> struct is_clock; +// template<class T> constexpr bool is_clock_v = is_clock<T>::value; + +// [time.traits.is.clock]/3: +// The behavior of a program that adds specializations for is_clock is undefined. + +// [namespace.std]/3: +// The behavior of a C++ program is undefined if it declares an explicit or partial specialization of any standard +// library variable template, except where explicitly permitted by the specification of that variable template. + +#include <chrono> +#include <ratio> + +#if !__has_warning("-Winvalid-specializations") +// expected-no-diagnostics +#else + +template <> +struct std::chrono::is_clock<int> : std::false_type {}; // expected-error@*:* {{'is_clock' cannot be specialized}} + +template <> +constexpr bool std::chrono::is_clock_v<float> = false; // expected-error@*:* {{'is_clock_v' cannot be specialized}} + +#endif diff --git a/libcxx/test/std/time/time.traits/is.clock.compile.pass.cpp b/libcxx/test/std/time/time.traits/is.clock.compile.pass.cpp new file mode 100644 index 0000000..4af29d2 --- /dev/null +++ b/libcxx/test/std/time/time.traits/is.clock.compile.pass.cpp @@ -0,0 +1,230 @@ +//===----------------------------------------------------------------------===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// + +// REQUIRES: std-at-least-c++20 + +// <chrono> +// +// template<class T> struct is_clock; +// template<class T> constexpr bool is_clock_v = is_clock<T>::value; + +#include <chrono> +#include <ratio> + +#include "test_macros.h" + +struct EmptyStruct {}; + +// Test structs missing required members +struct MissingRep { + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<MissingRep>; + static constexpr bool is_steady = false; + static time_point now(); +}; + +struct MissingPeriod { + using rep = long; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<MissingPeriod>; + static constexpr bool is_steady = false; + static time_point now(); +}; + +struct MissingDuration { + using rep = long; + using time_point = long; + static constexpr bool is_steady = false; + static time_point now(); +}; + +struct MissingTimePoint { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + static constexpr bool is_steady = false; + static std::chrono::time_point<MissingTimePoint> now(); +}; + +struct MissingIsSteady { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<MissingIsSteady>; + static time_point now(); +}; + +struct MissingNow { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<MissingNow>; + static constexpr bool is_steady = false; +}; + +// Valid clock types +struct ValidSteadyClock { + using rep = long long; + using period = std::nano; + using duration = std::chrono::nanoseconds; + using time_point = std::chrono::time_point<ValidSteadyClock>; + static constexpr bool is_steady = true; + static time_point now(); +}; + +struct ValidSystemClock { + using rep = long long; + using period = std::micro; + using duration = std::chrono::microseconds; + using time_point = std::chrono::time_point<ValidSystemClock>; + static constexpr bool is_steady = false; + static time_point now(); +}; + +// Test clocks with invalid is_steady type +struct WrongIsSteadyType { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<WrongIsSteadyType>; + static bool is_steady; // Not const bool + static time_point now(); +}; + +struct WrongIsSteadyNonBool { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<WrongIsSteadyNonBool>; + static constexpr int is_steady = 1; // Not bool + static time_point now(); +}; + +// Test clocks with invalid now() return type +struct WrongNowReturnType { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<WrongNowReturnType>; + static constexpr bool is_steady = false; + static int now(); // Wrong return type +}; + +// Test clocks with invalid period type +struct WrongPeriodType { + using rep = long; + using period = int; // Not a ratio + using duration = std::chrono::seconds; + using time_point = std::chrono::time_point<WrongPeriodType>; + static constexpr bool is_steady = false; + static time_point now(); +}; + +// Test clocks with wrong duration type +struct WrongDurationType { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::milliseconds; // Should be duration<long, ratio<1>> + using time_point = std::chrono::time_point<WrongDurationType>; + static constexpr bool is_steady = false; + static time_point now(); +}; + +// Test clocks with wrong time_point type +struct WrongTimePointType { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::duration<long, std::ratio<1>>; + using time_point = int; // Not a time_point + static constexpr bool is_steady = false; + static time_point now(); +}; + +struct WrongTimePointClock { + using rep = long; + using period = std::ratio<1>; + using duration = std::chrono::duration<long, std::ratio<1>>; + using time_point = std::chrono::time_point<ValidSystemClock>; // Wrong clock type + static constexpr bool is_steady = false; + static time_point now(); +}; + +// Valid clock with time_point that has matching duration instead of matching clock +struct ValidClockWithDurationMatch { + using rep = int; + using period = std::milli; + using duration = std::chrono::duration<int, std::milli>; + using time_point = std::chrono::time_point<ValidSystemClock, duration>; // Valid: matches duration + static constexpr bool is_steady = false; + static time_point now(); +}; + +// Test both is_clock and is_clock_v +static_assert(std::chrono::is_clock<std::chrono::system_clock>::value); +static_assert(std::chrono::is_clock_v<std::chrono::system_clock>); + +// Test standard clock types +static_assert(std::chrono::is_clock_v<std::chrono::system_clock>); +static_assert(std::chrono::is_clock_v<std::chrono::high_resolution_clock>); + +// Test non-clock types +static_assert(!std::chrono::is_clock_v<EmptyStruct>); +static_assert(!std::chrono::is_clock_v<int>); +static_assert(!std::chrono::is_clock_v<void>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock::time_point>); +static_assert(!std::chrono::is_clock_v<std::chrono::seconds>); +static_assert(!std::chrono::is_clock_v<std::chrono::milliseconds>); + +// Test structs missing required members +static_assert(!std::chrono::is_clock_v<MissingRep>); +static_assert(!std::chrono::is_clock_v<MissingPeriod>); +static_assert(!std::chrono::is_clock_v<MissingDuration>); +static_assert(!std::chrono::is_clock_v<MissingTimePoint>); +static_assert(!std::chrono::is_clock_v<MissingIsSteady>); +static_assert(!std::chrono::is_clock_v<MissingNow>); + +// Test valid custom clocks +static_assert(std::chrono::is_clock_v<ValidSteadyClock>); +static_assert(std::chrono::is_clock_v<ValidSystemClock>); +static_assert(std::chrono::is_clock_v<ValidClockWithDurationMatch>); + +// cv-qualified and reference types +static_assert(std::chrono::is_clock_v<const std::chrono::system_clock>); +static_assert(std::chrono::is_clock_v<volatile std::chrono::system_clock>); +static_assert(std::chrono::is_clock_v<const volatile std::chrono::system_clock>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock&>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock&&>); +static_assert(!std::chrono::is_clock_v<const std::chrono::system_clock&>); + +// array and pointer types +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock[]>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock[10]>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock*>); +static_assert(!std::chrono::is_clock_v<std::chrono::system_clock* const>); + +// The Standard defined a minimum set of checks and allowed implementation to perform stricter checks. The following +// static asserts are implementation specific and a conforming standard library implementation doesn't have to produce +// the same outcome. + +// Test clocks with invalid is_steady type +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongIsSteadyType>); // is_steady not const bool +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongIsSteadyNonBool>); // is_steady not bool type + +// Test clocks with invalid now() return type +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongNowReturnType>); // now() doesn't return time_point + +// Test clocks with invalid period type +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongPeriodType>); // period is not a ratio + +// Test clocks with wrong duration type +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongDurationType>); // duration doesn't match duration<rep, period> + +// Test clocks with wrong time_point type +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongTimePointType>); // time_point is not a time_point +LIBCPP_STATIC_ASSERT(!std::chrono::is_clock_v<WrongTimePointClock>); // time_point has wrong clock and wrong duration |