diff options
Diffstat (limited to 'test/std/utilities/time/time.duration')
53 files changed, 2014 insertions, 0 deletions
diff --git a/test/std/utilities/time/time.duration/default_ratio.pass.cpp b/test/std/utilities/time/time.duration/default_ratio.pass.cpp new file mode 100644 index 0000000000000..a34e27832bdc4 --- /dev/null +++ b/test/std/utilities/time/time.duration/default_ratio.pass.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// Test default template arg: + +// template <class Rep, class Period = ratio<1>> +// class duration; + +#include <chrono> +#include <type_traits> + +int main() +{ + static_assert((std::is_same<std::chrono::duration<int, std::ratio<1> >, + std::chrono::duration<int> >::value), ""); +} diff --git a/test/std/utilities/time/time.duration/duration.fail.cpp b/test/std/utilities/time/time.duration/duration.fail.cpp new file mode 100644 index 0000000000000..053616b79b437 --- /dev/null +++ b/test/std/utilities/time/time.duration/duration.fail.cpp @@ -0,0 +1,23 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// If a program instantiates duration with a duration type for the template +// argument Rep a diagnostic is required. + +#include <chrono> + +int main() +{ + typedef std::chrono::duration<std::chrono::milliseconds> D; + D d; +} diff --git a/test/std/utilities/time/time.duration/positive_num.fail.cpp b/test/std/utilities/time/time.duration/positive_num.fail.cpp new file mode 100644 index 0000000000000..e9096fd3fcb7a --- /dev/null +++ b/test/std/utilities/time/time.duration/positive_num.fail.cpp @@ -0,0 +1,22 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// Period::num shall be positive, diagnostic required. + +#include <chrono> + +int main() +{ + typedef std::chrono::duration<int, std::ratio<5, -1> > D; + D d; +} diff --git a/test/std/utilities/time/time.duration/ratio.fail.cpp b/test/std/utilities/time/time.duration/ratio.fail.cpp new file mode 100644 index 0000000000000..4ce0aaad003e6 --- /dev/null +++ b/test/std/utilities/time/time.duration/ratio.fail.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// Period shall be a specialization of ratio, diagnostic required. + +#include <chrono> + +template <int N, int D = 1> +class Ratio +{ +public: + static const int num = N; + static const int den = D; +}; + +int main() +{ + typedef std::chrono::duration<int, Ratio<1> > D; + D d; +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp new file mode 100644 index 0000000000000..8a8f4b1c0d9b0 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator++(); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::hours h(3); + std::chrono::hours& href = ++h; + assert(&href == &h); + assert(h.count() == 4); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp new file mode 100644 index 0000000000000..cf5028281007d --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_++int.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration operator++(int); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::hours h(3); + std::chrono::hours h2 = h++; + assert(h.count() == 4); + assert(h2.count() == 3); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp new file mode 100644 index 0000000000000..c0f10147ee893 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration operator+() const; + +#include <chrono> +#include <cassert> + +int main() +{ + { + const std::chrono::minutes m(3); + std::chrono::minutes m2 = +m; + assert(m.count() == m2.count()); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::minutes m(3); + constexpr std::chrono::minutes m2 = +m; + static_assert(m.count() == m2.count(), ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp new file mode 100644 index 0000000000000..8d8cf4539c16b --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_+=.pass.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator+=(const duration& d); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::seconds s(3); + s += std::chrono::seconds(2); + assert(s.count() == 5); + s += std::chrono::minutes(2); + assert(s.count() == 125); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp new file mode 100644 index 0000000000000..0aadfbcd5991e --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator--(); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::hours h(3); + std::chrono::hours& href = --h; + assert(&href == &h); + assert(h.count() == 2); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp new file mode 100644 index 0000000000000..7fc6a1df603f4 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_--int.pass.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration operator--(int); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::hours h(3); + std::chrono::hours h2 = h--; + assert(h.count() == 2); + assert(h2.count() == 3); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp new file mode 100644 index 0000000000000..00da6f69ca530 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-.pass.cpp @@ -0,0 +1,33 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration operator-() const; + +#include <chrono> +#include <cassert> + +int main() +{ + { + const std::chrono::minutes m(3); + std::chrono::minutes m2 = -m; + assert(m2.count() == -m.count()); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::minutes m(3); + constexpr std::chrono::minutes m2 = -m; + static_assert(m2.count() == -m.count(), ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp new file mode 100644 index 0000000000000..a0a7aed202b1b --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_-=.pass.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator-=(const duration& d); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::seconds s(3); + s -= std::chrono::seconds(2); + assert(s.count() == 1); + s -= std::chrono::minutes(2); + assert(s.count() == -119); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp new file mode 100644 index 0000000000000..09786bcd8cf84 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_divide=.pass.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator/=(const rep& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::nanoseconds ns(15); + ns /= 5; + assert(ns.count() == 3); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp new file mode 100644 index 0000000000000..8a4a2b4723244 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=duration.pass.cpp @@ -0,0 +1,27 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator%=(const duration& rhs) + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::microseconds us(11); + std::chrono::microseconds us2(3); + us %= us2; + assert(us.count() == 2); + us %= std::chrono::milliseconds(3); + assert(us.count() == 2); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp new file mode 100644 index 0000000000000..8758e17ba6afd --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_mod=rep.pass.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator%=(const rep& rhs) + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::microseconds us(11); + us %= 3; + assert(us.count() == 2); +} diff --git a/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp new file mode 100644 index 0000000000000..b97534a3615a9 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.arithmetic/op_times=.pass.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration& operator*=(const rep& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::nanoseconds ns(3); + ns *= 5; + assert(ns.count() == 15); +} diff --git a/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp new file mode 100644 index 0000000000000..1c87fcd909efc --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cast/duration_cast.pass.cpp @@ -0,0 +1,52 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class ToDuration, class Rep, class Period> +// constexpr +// ToDuration +// duration_cast(const duration<Rep, Period>& d); + +#include <chrono> +#include <type_traits> +#include <cassert> + +template <class ToDuration, class FromDuration> +void +test(const FromDuration& f, const ToDuration& d) +{ + { + typedef decltype(std::chrono::duration_cast<ToDuration>(f)) R; + static_assert((std::is_same<R, ToDuration>::value), ""); + assert(std::chrono::duration_cast<ToDuration>(f) == d); + } +} + +int main() +{ + test(std::chrono::milliseconds(7265000), std::chrono::hours(2)); + test(std::chrono::milliseconds(7265000), std::chrono::minutes(121)); + test(std::chrono::milliseconds(7265000), std::chrono::seconds(7265)); + test(std::chrono::milliseconds(7265000), std::chrono::milliseconds(7265000)); + test(std::chrono::milliseconds(7265000), std::chrono::microseconds(7265000000LL)); + test(std::chrono::milliseconds(7265000), std::chrono::nanoseconds(7265000000000LL)); + test(std::chrono::milliseconds(7265000), + std::chrono::duration<double, std::ratio<3600> >(7265./3600)); + test(std::chrono::duration<int, std::ratio<2, 3> >(9), + std::chrono::duration<int, std::ratio<3, 5> >(10)); +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::hours h = std::chrono::duration_cast<std::chrono::hours>(std::chrono::milliseconds(7265000)); + static_assert(h.count() == 2, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp new file mode 100644 index 0000000000000..13dd8f44c364e --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cast/toduration.fail.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class ToDuration, class Rep, class Period> +// ToDuration +// duration_cast(const duration<Rep, Period>& d); + +// ToDuration shall be an instantiation of duration. + +#include <chrono> + +int main() +{ + std::chrono::duration_cast<int>(std::chrono::milliseconds(3)); +} diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp new file mode 100644 index 0000000000000..2d0dd94d4cf65 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_equal.pass.cpp @@ -0,0 +1,115 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator==(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator!=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(3); + assert(s1 == s2); + assert(!(s1 != s2)); + } + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(4); + assert(!(s1 == s2)); + assert(s1 != s2); + } + { + std::chrono::milliseconds s1(3); + std::chrono::microseconds s2(3000); + assert(s1 == s2); + assert(!(s1 != s2)); + } + { + std::chrono::milliseconds s1(3); + std::chrono::microseconds s2(4000); + assert(!(s1 == s2)); + assert(s1 != s2); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(9); + std::chrono::duration<int, std::ratio<3, 5> > s2(10); + assert(s1 == s2); + assert(!(s1 != s2)); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(10); + std::chrono::duration<int, std::ratio<3, 5> > s2(9); + assert(!(s1 == s2)); + assert(s1 != s2); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(9); + std::chrono::duration<double, std::ratio<3, 5> > s2(10); + assert(s1 == s2); + assert(!(s1 != s2)); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(3); + static_assert(s1 == s2, ""); + static_assert(!(s1 != s2), ""); + } + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(4); + static_assert(!(s1 == s2), ""); + static_assert(s1 != s2, ""); + } + { + constexpr std::chrono::milliseconds s1(3); + constexpr std::chrono::microseconds s2(3000); + static_assert(s1 == s2, ""); + static_assert(!(s1 != s2), ""); + } + { + constexpr std::chrono::milliseconds s1(3); + constexpr std::chrono::microseconds s2(4000); + static_assert(!(s1 == s2), ""); + static_assert(s1 != s2, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(9); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(10); + static_assert(s1 == s2, ""); + static_assert(!(s1 != s2), ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(10); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(9); + static_assert(!(s1 == s2), ""); + static_assert(s1 != s2, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(9); + constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(10); + static_assert(s1 == s2, ""); + static_assert(!(s1 != s2), ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp new file mode 100644 index 0000000000000..9d875579f3262 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.comparisons/op_less.pass.cpp @@ -0,0 +1,153 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator< (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator> (const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator<=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// bool +// operator>=(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(3); + assert(!(s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert( (s1 >= s2)); + } + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(4); + assert( (s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert(!(s1 >= s2)); + } + { + std::chrono::milliseconds s1(3); + std::chrono::microseconds s2(3000); + assert(!(s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert( (s1 >= s2)); + } + { + std::chrono::milliseconds s1(3); + std::chrono::microseconds s2(4000); + assert( (s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert(!(s1 >= s2)); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(9); + std::chrono::duration<int, std::ratio<3, 5> > s2(10); + assert(!(s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert( (s1 >= s2)); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(10); + std::chrono::duration<int, std::ratio<3, 5> > s2(9); + assert(!(s1 < s2)); + assert( (s1 > s2)); + assert(!(s1 <= s2)); + assert( (s1 >= s2)); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(9); + std::chrono::duration<double, std::ratio<3, 5> > s2(10); + assert(!(s1 < s2)); + assert(!(s1 > s2)); + assert( (s1 <= s2)); + assert( (s1 >= s2)); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(3); + static_assert(!(s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert( (s1 >= s2), ""); + } + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(4); + static_assert( (s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert(!(s1 >= s2), ""); + } + { + constexpr std::chrono::milliseconds s1(3); + constexpr std::chrono::microseconds s2(3000); + static_assert(!(s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert( (s1 >= s2), ""); + } + { + constexpr std::chrono::milliseconds s1(3); + constexpr std::chrono::microseconds s2(4000); + static_assert( (s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert(!(s1 >= s2), ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(9); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(10); + static_assert(!(s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert( (s1 >= s2), ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(10); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(9); + static_assert(!(s1 < s2), ""); + static_assert( (s1 > s2), ""); + static_assert(!(s1 <= s2), ""); + static_assert( (s1 >= s2), ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(9); + constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(10); + static_assert(!(s1 < s2), ""); + static_assert(!(s1 > s2), ""); + static_assert( (s1 <= s2), ""); + static_assert( (s1 >= s2), ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp new file mode 100644 index 0000000000000..152227d82a823 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_exact.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// exact conversions allowed for integral reps + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::milliseconds ms(1); + std::chrono::microseconds us = ms; + assert(us.count() == 1000); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::milliseconds ms(1); + constexpr std::chrono::microseconds us = ms; + static_assert(us.count() == 1000, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp new file mode 100644 index 0000000000000..04c082578289f --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_float_to_int.fail.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// conversions from floating point to integral durations disallowed + +#include <chrono> + +int main() +{ + std::chrono::duration<double> d; + std::chrono::duration<int> i = d; +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp new file mode 100644 index 0000000000000..e82e25e8f694c --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.fail.cpp @@ -0,0 +1,25 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// inexact conversions disallowed for integral reps + +#include <chrono> + +int main() +{ + std::chrono::microseconds us(1); + std::chrono::milliseconds ms = us; +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp new file mode 100644 index 0000000000000..519b2b141c298 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_inexact.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// inexact conversions allowed for floating point reps + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::duration<double, std::micro> us(1); + std::chrono::duration<double, std::milli> ms = us; + assert(ms.count() == 1./1000); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::duration<double, std::micro> us(1); + constexpr std::chrono::duration<double, std::milli> ms = us; + static_assert(ms.count() == 1./1000, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp new file mode 100644 index 0000000000000..59fefe2e002d5 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_int_to_float.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// conversions from integral to floating point durations allowed + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::duration<int> i(3); + std::chrono::duration<double, std::milli> d = i; + assert(d.count() == 3000); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::duration<int> i(3); + constexpr std::chrono::duration<double, std::milli> d = i; + static_assert(d.count() == 3000, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp new file mode 100644 index 0000000000000..74b65d6b9cc7e --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/convert_overflow.pass.cpp @@ -0,0 +1,37 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2, class Period2> +// duration(const duration<Rep2, Period2>& d); + +// overflow should SFINAE instead of error out, LWG 2094 + +#include <chrono> +#include <cassert> + +bool called = false; + +void f(std::chrono::milliseconds); +void f(std::chrono::seconds) +{ + called = true; +} + +int main() +{ + { + std::chrono::duration<int, std::exa> r(1); + f(r); + assert(called); + } +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp new file mode 100644 index 0000000000000..c52990961c259 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/default.pass.cpp @@ -0,0 +1,38 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// duration() = default; + +// Rep must be default initialized, not initialized with 0 + +#include <chrono> +#include <cassert> + +#include "../../rep.h" + +template <class D> +void +test() +{ + D d; + assert(d.count() == typename D::rep()); +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + constexpr D d2 = D(); + static_assert(d2.count() == typename D::rep(), ""); +#endif +} + +int main() +{ + test<std::chrono::duration<Rep> >(); +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp new file mode 100644 index 0000000000000..20f81619bd125 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/rep.pass.cpp @@ -0,0 +1,40 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2> +// explicit duration(const Rep2& r); + +#include <chrono> +#include <cassert> + +#include "../../rep.h" + +template <class D, class R> +void +test(R r) +{ + D d(r); + assert(d.count() == r); +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + constexpr D d2(R(2)); + static_assert(d2.count() == 2, ""); +#endif +} + +int main() +{ + test<std::chrono::duration<int> >(5); + test<std::chrono::duration<int, std::ratio<3, 2> > >(5); + test<std::chrono::duration<Rep, std::ratio<3, 2> > >(Rep(3)); + test<std::chrono::duration<double, std::ratio<2, 3> > >(5.5); +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp new file mode 100644 index 0000000000000..9f071ca1afc0f --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/rep01.fail.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2> +// explicit duration(const Rep2& r); + +// test for explicit + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<int> d = 1; +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp new file mode 100644 index 0000000000000..37f32e77686a1 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.fail.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2> +// explicit duration(const Rep2& r); + +// Rep2 shall be implicitly convertible to rep + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<Rep> d(1); +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp new file mode 100644 index 0000000000000..b3ba9f7081e45 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/rep02.pass.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2> +// explicit duration(const Rep2& r); + +// construct double with int + +#include <chrono> +#include <cassert> + +int main() +{ + std::chrono::duration<double> d(5); + assert(d.count() == 5); +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + constexpr std::chrono::duration<double> d2(5); + static_assert(d2.count() == 5, ""); +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp new file mode 100644 index 0000000000000..4ace54b231ffe --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.cons/rep03.fail.cpp @@ -0,0 +1,24 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep2> +// explicit duration(const Rep2& r); + +// treat_as_floating_point<Rep2>::value shall be false + +#include <chrono> + +int main() +{ + std::chrono::duration<int> d(1.); +} diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp new file mode 100644 index 0000000000000..48324ae836513 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.literals/literals.pass.cpp @@ -0,0 +1,59 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +#include <chrono> +#include <type_traits> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + using namespace std::literals::chrono_literals; + +// Make sure the types are right + static_assert ( std::is_same<decltype( 3h ), std::chrono::hours>::value, "" ); + static_assert ( std::is_same<decltype( 3min ), std::chrono::minutes>::value, "" ); + static_assert ( std::is_same<decltype( 3s ), std::chrono::seconds>::value, "" ); + static_assert ( std::is_same<decltype( 3ms ), std::chrono::milliseconds>::value, "" ); + static_assert ( std::is_same<decltype( 3us ), std::chrono::microseconds>::value, "" ); + static_assert ( std::is_same<decltype( 3ns ), std::chrono::nanoseconds>::value, "" ); + + std::chrono::hours h = 4h; + assert ( h == std::chrono::hours(4)); + auto h2 = 4.0h; + assert ( h == h2 ); + + std::chrono::minutes min = 36min; + assert ( min == std::chrono::minutes(36)); + auto min2 = 36.0min; + assert ( min == min2 ); + + std::chrono::seconds s = 24s; + assert ( s == std::chrono::seconds(24)); + auto s2 = 24.0s; + assert ( s == s2 ); + + std::chrono::milliseconds ms = 247ms; + assert ( ms == std::chrono::milliseconds(247)); + auto ms2 = 247.0ms; + assert ( ms == ms2 ); + + std::chrono::microseconds us = 867us; + assert ( us == std::chrono::microseconds(867)); + auto us2 = 867.0us; + assert ( us == us2 ); + + std::chrono::nanoseconds ns = 645ns; + assert ( ns == std::chrono::nanoseconds(645)); + auto ns2 = 645.ns; + assert ( ns == ns2 ); +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp new file mode 100644 index 0000000000000..46aaa30e51e4a --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.fail.cpp @@ -0,0 +1,21 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include <chrono> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + std::chrono::hours h = 4h; // should fail w/conversion operator not found +#else +#error +#endif +} + diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp new file mode 100644 index 0000000000000..574f9bcce8741 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.literals/literals1.pass.cpp @@ -0,0 +1,48 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include <chrono> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + using namespace std::chrono; + + hours h = 4h; + assert ( h == hours(4)); + auto h2 = 4.0h; + assert ( h == h2 ); + + minutes min = 36min; + assert ( min == minutes(36)); + auto min2 = 36.0min; + assert ( min == min2 ); + + seconds s = 24s; + assert ( s == seconds(24)); + auto s2 = 24.0s; + assert ( s == s2 ); + + milliseconds ms = 247ms; + assert ( ms == milliseconds(247)); + auto ms2 = 247.0ms; + assert ( ms == ms2 ); + + microseconds us = 867us; + assert ( us == microseconds(867)); + auto us2 = 867.0us; + assert ( us == us2 ); + + nanoseconds ns = 645ns; + assert ( ns == nanoseconds(645)); + auto ns2 = 645.ns; + assert ( ns == ns2 ); +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp new file mode 100644 index 0000000000000..17358e589f4fa --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.fail.cpp @@ -0,0 +1,22 @@ +// -*- C++ -*- +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +#include <chrono> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + using std::chrono::hours; + + hours foo = 4h; // should fail w/conversion operator not found +#else +#error +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp new file mode 100644 index 0000000000000..e37bc6e679614 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.literals/literals2.pass.cpp @@ -0,0 +1,51 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +#include <chrono> +#include <type_traits> +#include <cassert> + +int main() +{ +#if _LIBCPP_STD_VER > 11 + using namespace std::literals; + + std::chrono::hours h = 4h; + assert ( h == std::chrono::hours(4)); + auto h2 = 4.0h; + assert ( h == h2 ); + + std::chrono::minutes min = 36min; + assert ( min == std::chrono::minutes(36)); + auto min2 = 36.0min; + assert ( min == min2 ); + + std::chrono::seconds s = 24s; + assert ( s == std::chrono::seconds(24)); + auto s2 = 24.0s; + assert ( s == s2 ); + + std::chrono::milliseconds ms = 247ms; + assert ( ms == std::chrono::milliseconds(247)); + auto ms2 = 247.0ms; + assert ( ms == ms2 ); + + std::chrono::microseconds us = 867us; + assert ( us == std::chrono::microseconds(867)); + auto us2 = 867.0us; + assert ( us == us2 ); + + std::chrono::nanoseconds ns = 645ns; + assert ( ns == std::chrono::nanoseconds(645)); + auto ns2 = 645.ns; + assert ( ns == ns2 ); +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp new file mode 100644 index 0000000000000..6585351cb4c8e --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_+.pass.cpp @@ -0,0 +1,73 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type +// operator+(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(5); + std::chrono::seconds r = s1 + s2; + assert(r.count() == 8); + } + { + std::chrono::seconds s1(3); + std::chrono::microseconds s2(5); + std::chrono::microseconds r = s1 + s2; + assert(r.count() == 3000005); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(3); + std::chrono::duration<int, std::ratio<3, 5> > s2(5); + std::chrono::duration<int, std::ratio<1, 15> > r = s1 + s2; + assert(r.count() == 75); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(3); + std::chrono::duration<double, std::ratio<3, 5> > s2(5); + std::chrono::duration<double, std::ratio<1, 15> > r = s1 + s2; + assert(r.count() == 75); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(5); + constexpr std::chrono::seconds r = s1 + s2; + static_assert(r.count() == 8, ""); + } + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::microseconds s2(5); + constexpr std::chrono::microseconds r = s1 + s2; + static_assert(r.count() == 3000005, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(3); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(5); + constexpr std::chrono::duration<int, std::ratio<1, 15> > r = s1 + s2; + static_assert(r.count() == 75, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(3); + constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(5); + constexpr std::chrono::duration<double, std::ratio<1, 15> > r = s1 + s2; + static_assert(r.count() == 75, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp new file mode 100644 index 0000000000000..fac58b9716d3b --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_-.pass.cpp @@ -0,0 +1,74 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type +// operator-(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::seconds s1(3); + std::chrono::seconds s2(5); + std::chrono::seconds r = s1 - s2; + assert(r.count() == -2); + } + { + std::chrono::seconds s1(3); + std::chrono::microseconds s2(5); + std::chrono::microseconds r = s1 - s2; + assert(r.count() == 2999995); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(3); + std::chrono::duration<int, std::ratio<3, 5> > s2(5); + std::chrono::duration<int, std::ratio<1, 15> > r = s1 - s2; + assert(r.count() == -15); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(3); + std::chrono::duration<double, std::ratio<3, 5> > s2(5); + std::chrono::duration<double, std::ratio<1, 15> > r = s1 - s2; + assert(r.count() == -15); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::seconds s2(5); + constexpr std::chrono::seconds r = s1 - s2; + static_assert(r.count() == -2, ""); + } + { + constexpr std::chrono::seconds s1(3); + constexpr std::chrono::microseconds s2(5); + constexpr std::chrono::microseconds r = s1 - s2; + static_assert(r.count() == 2999995, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(3); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(5); + constexpr std::chrono::duration<int, std::ratio<1, 15> > r = s1 - s2; + static_assert(r.count() == -15, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(3); + constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(5); + constexpr std::chrono::duration<double, std::ratio<1, 15> > r = s1 - s2; + static_assert(r.count() == -15, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp new file mode 100644 index 0000000000000..6b24676f100cf --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_duration.pass.cpp @@ -0,0 +1,66 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// typename common_type<Rep1, Rep2>::type +// operator/(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::nanoseconds ns1(15); + std::chrono::nanoseconds ns2(5); + assert(ns1 / ns2 == 3); + } + { + std::chrono::microseconds us1(15); + std::chrono::nanoseconds ns2(5); + assert(us1 / ns2 == 3000); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(30); + std::chrono::duration<int, std::ratio<3, 5> > s2(5); + assert(s1 / s2 == 6); + } + { + std::chrono::duration<int, std::ratio<2, 3> > s1(30); + std::chrono::duration<double, std::ratio<3, 5> > s2(5); + assert(s1 / s2 == 20./3); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::nanoseconds ns1(15); + constexpr std::chrono::nanoseconds ns2(5); + static_assert(ns1 / ns2 == 3, ""); + } + { + constexpr std::chrono::microseconds us1(15); + constexpr std::chrono::nanoseconds ns2(5); + static_assert(us1 / ns2 == 3000, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(30); + constexpr std::chrono::duration<int, std::ratio<3, 5> > s2(5); + static_assert(s1 / s2 == 6, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<2, 3> > s1(30); + constexpr std::chrono::duration<double, std::ratio<3, 5> > s2(5); + static_assert(s1 / s2 == 20./3, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp new file mode 100644 index 0000000000000..db725773fd474 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.fail.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator/(const duration<Rep1, Period>& d, const Rep2& s); + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<Rep> d(Rep(15)); + d = d / 5; +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp new file mode 100644 index 0000000000000..3036cde5bf677 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_divide_rep.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// constexpr +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator/(const duration<Rep1, Period>& d, const Rep2& s); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::nanoseconds ns(15); + ns = ns / 5; + assert(ns.count() == 3); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::nanoseconds ns(15); + constexpr std::chrono::nanoseconds ns2 = ns / 5; + static_assert(ns2.count() == 3, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp new file mode 100644 index 0000000000000..e69f3205d14ff --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_duration.pass.cpp @@ -0,0 +1,62 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period1, class Rep2, class Period2> +// constexpr +// typename common_type<duration<Rep1, Period1>, duration<Rep2, Period2>>::type +// operator%(const duration<Rep1, Period1>& lhs, const duration<Rep2, Period2>& rhs); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::nanoseconds ns1(15); + std::chrono::nanoseconds ns2(6); + std::chrono::nanoseconds r = ns1 % ns2; + assert(r.count() == 3); + } + { + std::chrono::microseconds us1(15); + std::chrono::nanoseconds ns2(28); + std::chrono::nanoseconds r = us1 % ns2; + assert(r.count() == 20); + } + { + std::chrono::duration<int, std::ratio<3, 5> > s1(6); + std::chrono::duration<int, std::ratio<2, 3> > s2(3); + std::chrono::duration<int, std::ratio<1, 15> > r = s1 % s2; + assert(r.count() == 24); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::nanoseconds ns1(15); + constexpr std::chrono::nanoseconds ns2(6); + constexpr std::chrono::nanoseconds r = ns1 % ns2; + static_assert(r.count() == 3, ""); + } + { + constexpr std::chrono::microseconds us1(15); + constexpr std::chrono::nanoseconds ns2(28); + constexpr std::chrono::nanoseconds r = us1 % ns2; + static_assert(r.count() == 20, ""); + } + { + constexpr std::chrono::duration<int, std::ratio<3, 5> > s1(6); + constexpr std::chrono::duration<int, std::ratio<2, 3> > s2(3); + constexpr std::chrono::duration<int, std::ratio<1, 15> > r = s1 % s2; + static_assert(r.count() == 24, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp new file mode 100644 index 0000000000000..16e511d44f66f --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.fail.cpp @@ -0,0 +1,26 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator%(const duration<Rep1, Period>& d, const Rep2& s) + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<Rep> d(Rep(15)); + d = d % 5; +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp new file mode 100644 index 0000000000000..1acbe34ea5eb1 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_mod_rep.pass.cpp @@ -0,0 +1,36 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// constexpr +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator%(const duration<Rep1, Period>& d, const Rep2& s) + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::nanoseconds ns(15); + ns = ns % 6; + assert(ns.count() == 3); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::nanoseconds ns(15); + constexpr std::chrono::nanoseconds ns2 = ns % 6; + static_assert(ns2.count() == 3, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp new file mode 100644 index 0000000000000..190e74b1dc32a --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep.pass.cpp @@ -0,0 +1,45 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// constexpr +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const duration<Rep1, Period>& d, const Rep2& s); + +// template <class Rep1, class Period, class Rep2> +// constexpr +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const Rep1& s, const duration<Rep2, Period>& d); + +#include <chrono> +#include <cassert> + +int main() +{ + { + std::chrono::nanoseconds ns(3); + ns = ns * 5; + assert(ns.count() == 15); + ns = 6 * ns; + assert(ns.count() == 90); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + constexpr std::chrono::nanoseconds ns(3); + constexpr std::chrono::nanoseconds ns2 = ns * 5; + static_assert(ns2.count() == 15, ""); + constexpr std::chrono::nanoseconds ns3 = 6 * ns; + static_assert(ns3.count() == 18, ""); + } +#endif +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp new file mode 100644 index 0000000000000..d8160500f916e --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep1.fail.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const duration<Rep1, Period>& d, const Rep2& s); + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const Rep1& s, const duration<Rep2, Period>& d); + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<Rep> d; + d = d * 5; +} diff --git a/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp new file mode 100644 index 0000000000000..e224ba9421099 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.nonmember/op_times_rep2.fail.cpp @@ -0,0 +1,30 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const duration<Rep1, Period>& d, const Rep2& s); + +// template <class Rep1, class Period, class Rep2> +// duration<typename common_type<Rep1, Rep2>::type, Period> +// operator*(const Rep1& s, const duration<Rep2, Period>& d); + +#include <chrono> + +#include "../../rep.h" + +int main() +{ + std::chrono::duration<Rep> d; + d = 5 * d; +} diff --git a/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp new file mode 100644 index 0000000000000..b58f5c55b643a --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.observer/tested_elsewhere.pass.cpp @@ -0,0 +1,12 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +int main() +{ +} diff --git a/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp new file mode 100644 index 0000000000000..405461e88ae9b --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.special/max.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// static constexpr duration max(); + +#include <chrono> +#include <limits> +#include <cassert> + +#include "../../rep.h" + +template <class D> +void test() +{ + { + typedef typename D::rep Rep; + Rep max_rep = std::chrono::duration_values<Rep>::max(); + assert(D::max().count() == max_rep); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + typedef typename D::rep Rep; + constexpr Rep max_rep = std::chrono::duration_values<Rep>::max(); + static_assert(D::max().count() == max_rep, ""); + } +#endif +} + +int main() +{ + test<std::chrono::duration<int> >(); + test<std::chrono::duration<Rep> >(); +} diff --git a/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp new file mode 100644 index 0000000000000..44cd64eff3d36 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.special/min.pass.cpp @@ -0,0 +1,43 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// static constexpr duration min(); + +#include <chrono> +#include <limits> +#include <cassert> + +#include "../../rep.h" + +template <class D> +void test() +{ + { + typedef typename D::rep Rep; + Rep min_rep = std::chrono::duration_values<Rep>::min(); + assert(D::min().count() == min_rep); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + typedef typename D::rep Rep; + constexpr Rep min_rep = std::chrono::duration_values<Rep>::min(); + static_assert(D::min().count() == min_rep, ""); + } +#endif +} + +int main() +{ + test<std::chrono::duration<int> >(); + test<std::chrono::duration<Rep> >(); +} diff --git a/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp new file mode 100644 index 0000000000000..18350fe2ff476 --- /dev/null +++ b/test/std/utilities/time/time.duration/time.duration.special/zero.pass.cpp @@ -0,0 +1,42 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// static constexpr duration zero(); + +#include <chrono> +#include <cassert> + +#include "../../rep.h" + +template <class D> +void test() +{ + { + typedef typename D::rep Rep; + Rep zero_rep = std::chrono::duration_values<Rep>::zero(); + assert(D::zero().count() == zero_rep); + } +#ifndef _LIBCPP_HAS_NO_CONSTEXPR + { + typedef typename D::rep Rep; + constexpr Rep zero_rep = std::chrono::duration_values<Rep>::zero(); + static_assert(D::zero().count() == zero_rep, ""); + } +#endif +} + +int main() +{ + test<std::chrono::duration<int> >(); + test<std::chrono::duration<Rep> >(); +} diff --git a/test/std/utilities/time/time.duration/types.pass.cpp b/test/std/utilities/time/time.duration/types.pass.cpp new file mode 100644 index 0000000000000..8eaffe77651cc --- /dev/null +++ b/test/std/utilities/time/time.duration/types.pass.cpp @@ -0,0 +1,27 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +// <chrono> + +// duration + +// Test nested types + +// typedef Rep rep; +// typedef Period period; + +#include <chrono> +#include <type_traits> + +int main() +{ + typedef std::chrono::duration<long, std::ratio<3, 2> > D; + static_assert((std::is_same<D::rep, long>::value), ""); + static_assert((std::is_same<D::period, std::ratio<3, 2> >::value), ""); +} |