hdkv/yuzu
1
Fork 0
Code Issues Pull Requests Releases 1 Activity

early-access version 3088

Browse Source
This commit is contained in:
pineappleEA
2022-11-05 15:35:56 +01:00
parent 4e4fc25ce3
commit b601909c6d
35519 changed files with 5996896 additions and 860 deletions
Download Patch File Download Diff File Expand all files Collapse all files

465
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/Jamfile.v2 vendored Executable file
View File

@@ -0,0 +1,465 @@
# Boost Chrono Library test Jamfile
# Copyright Beman Dawes 2008
# Copyright Vicente J. Botet Escriba 2009-2010
# Distributed under the Boost Software License, Version 1.0.
# See accompanying file LICENSE_1_0.txt or http://www.boost.org/LICENSE_1_0.txt
# See library home page at http://www.boost.org/libs/chrono
import testing ;
import os ;
import feature ;
project
: requirements
<target-os>freebsd:<linkflags>"-lrt"
<target-os>linux:<linkflags>"-lrt -lpthread"
<toolset>clang/<target-os>linux:<linkflags>"-lpthread"
<toolset>pgi:<linkflags>"-lrt"
#<threading>single:<define>BOOST_CHRONO_THREAD_DISABLED
<toolset>msvc:<asynch-exceptions>on
<define>BOOST_CHRONO_USES_MPL_ASSERT
#<toolset>sun:<define>BOOST_COMMON_TYPE_DONT_USE_TYPEOF
#<toolset>sun:<define>BOOST_TYPEOF_EMULATION
<toolset>sun:<define>__typeof__=__typeof__
<warnings>all
<toolset>gcc:<cxxflags>-Wextra
#<toolset>gcc:<cxxflags>-pedantic
<toolset>clang:<warnings>on
<toolset>gcc:<cxxflags>-Wno-long-long
<toolset>gcc:<cxxflags>-Wno-variadic-macros
<toolset>darwin:<cxxflags>-Wextra
<toolset>darwin:<cxxflags>-pedantic
<toolset>darwin:<cxxflags>-Wno-long-long
<toolset>darwin:<cxxflags>-Wno-variadic-macros
#<toolset>pathscale:<cxxflags>-Wextra
<toolset>pathscale:<cxxflags>-Wno-long-long
<toolset>pathscale:<cxxflags>-pedantic
<toolset>clang:<cxxflags>-Wextra
<toolset>clang:<cxxflags>-pedantic
<toolset>clang:<cxxflags>-Wno-long-long
<toolset>clang:<cxxflags>-Wno-variadic-macros
<toolset>gcc-4.5.0,<target-os>windows:<cxxflags>-Wno-missing-field-initializers
<toolset>gcc-4.5.0,<target-os>windows:<cxxflags>-fdiagnostics-show-option
<toolset>msvc:<cxxflags>/wd4127
<toolset>msvc:<cxxflags>/wd4512
# Note: Some of the remarks from the Intel compiler are disabled
# remark #193: zero used for undefined preprocessing identifier "XXX"
# remark #304: access control not specified ("public" by default)
# remark #383: value copied to temporary, reference to temporary used
# remark #444: destructor for base class "XXX" (declared at line YYY") is not virtual
# remark #593: variable "XXX" was set but never used
# remark #981: operands are evaluated in unspecified order
# remark #1418: external function definition with no prior declaration
# remark #2415: variable "XXX" of static storage duration was declared but never referenced
<toolset>intel:<cxxflags>-wd193,304,383,444
<toolset>intel:<cxxflags>-wd593,981
<toolset>intel:<cxxflags>-wd1418
<toolset>intel:<cxxflags>-wd2415
;
rule chrono-run ( sources )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
#[ run $(sources) ../build//boost_chrono/<link>static
# : :
# :
# : $(sources[1]:B)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-runXXX ( sources )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
#[ run $(sources) ../build//boost_chrono/<link>static
# : :
# :
# : $(sources[1]:B)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-v1-v2-run ( sources )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
[ run $(sources) ../build//boost_chrono/<link>static
: :
:
: v1_$(sources[1]:B)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
#<define>BOOST_CHRONO_VERSION=1
: v1_$(sources[1]:B)_h ]
;
}
rule chrono-run2 ( sources : name )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_d ]
#[ run $(sources) ../build//boost_chrono/<link>static
# : :
# :
# : $(name)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(name)_h ]
;
}
rule date-run ( sources + )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
;
}
rule date-run-2 ( sources + : name )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_d ]
;
}
rule chrono-run-mt ( sources )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
#[ run $(sources) ../build//boost_chrono/<link>static
# : :
# :
# : $(sources[1]:B)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-run2-mt ( sources * : name )
{
return
[ run $(sources) ../build//boost_chrono
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_d ]
#[ run $(sources) ../build//boost_chrono/<link>static
# : :
# :
# : $(name)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(name)_h ]
;
}
rule chrono-run-check ( sources )
{
return
[ run $(sources)
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_d ]
[ run $(sources)
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-run-check2 ( sources : name )
{
return
[ run $(sources)
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_d ]
[ run $(sources)
: :
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_s ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(name)_h ]
;
}
rule chrono-run-header ( sources )
{
return
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-v1-v2-run-header ( sources )
{
return
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
: v1_$(sources[1]:B)_h ]
;
}
rule chrono-run-header2 ( sources : name )
{
return
[ run $(sources)
: :
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(name)_h ]
;
}
rule chrono-compile ( sources )
{
return
[ compile $(sources)
:
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_l ]
[ compile $(sources)
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(sources[1]:B)_h ]
;
}
rule chrono-compile2 ( sources : name )
{
return
[ compile $(sources)
:
<define>BOOST_CHRONO_VERSION=2
: $(name)_l ]
[ compile $(sources)
: <define>BOOST_CHRONO_HEADER_ONLY
<define>BOOST_ERROR_CODE_HEADER_ONLY
#<define>BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
<define>BOOST_CHRONO_VERSION=2
: $(name)_h ]
;
}
test-suite "examples"
:
[ chrono-run-header ../example/cycle_count.cpp ]
[ chrono-run-header ../example/runtime_resolution.cpp ]
[ chrono-run-header ../example/xtime.cpp ]
[ chrono-run-header ../example/saturating.cpp ]
[ chrono-run ../example/min_time_point.cpp ]
[ chrono-run-header ../example/i_dont_like_the_default_duration_behavior.cpp ]
[ chrono-run ../example/simulated_thread_interface_demo.cpp ]
[ chrono-run-header ../example/timeval_demo.cpp ]
[ chrono-run ../example/chrono_unit_test.cpp ]
[ chrono-run-header ../example/explore_limits.cpp ]
[ chrono-run-header ../example/test_duration.cpp ]
[ chrono-run ../example/test_clock.cpp ]
[ chrono-run-header ../example/miscellaneous.cpp ]
[ chrono-run-header ../example/test_special_values.cpp ]
[ chrono-run ../example/manipulate_clock_object.cpp ]
[ chrono-run-mt ../example/test_thread_clock.cpp ]
[ chrono-run-header ../example/rounding.cpp ]
#[ chrono-run ../example/await_keystroke.cpp ]
;
test-suite "traits"
:
[ chrono-compile2 traits/common_type_duration_pass.cpp : traits_common_type_duration_p ]
[ chrono-compile2 traits/common_type_time_point_pass.cpp : traits_common_type_time_point_p ]
[ chrono-compile2 traits/treat_as_floating_point_pass.cpp : traits_treat_as_floating_point_p ]
[ chrono-run-header2 traits/duration_values_pass.cpp : traits_duration_values_p ]
;
test-suite "duration"
:
[ compile-fail duration/duration_duration_fail.cpp ]
[ compile-fail duration/ratio_fail.cpp ]
[ compile-fail duration/positive_num_fail.cpp ]
[ chrono-compile duration/default_ratio_pass.cpp ]
[ chrono-compile duration/types_pass.cpp ]
[ chrono-compile duration/ratio_alias_pass.cpp ]
[ chrono-compile duration/typedefs_pass.cpp ]
[ chrono-run-header duration/arithmetic_pass.cpp ]
[ chrono-run-header duration/duration_cast_pass.cpp ]
[ compile-fail duration/duration_cast_int_fail.cpp ]
[ chrono-run-header duration/comparisons_pass.cpp ]
[ chrono-run-header duration/constructor_pass.cpp ]
[ compile-fail duration/cons/convert_float_to_int_fail.cpp ]
[ compile-fail duration/cons/convert_inexact_fail.cpp ]
[ compile-fail duration/cons/implicit_constructot_fail.cpp ]
[ compile-fail duration/cons/non_implicit_convertible_rep_fail.cpp ]
[ compile-fail duration/cons/treat_as_floating_point_Rep2_true_fail.cpp ]
[ compile-fail duration/nonmember/divide_rep2_fail.cpp ]
[ compile-fail duration/nonmember/modulus_rep2_fail.cpp ]
[ compile-fail duration/nonmember/times_rep2_lhs_fail.cpp ]
[ compile-fail duration/nonmember/times_rep2_rhs_fail.cpp ]
[ chrono-run-header duration/duration_values_pass.cpp ]
[ chrono-run-header duration/rounding_pass.cpp ]
;
test-suite "time_point"
:
[ chrono-compile2 time_point/default_duration_pass.cpp : time_point_default_duration_p ]
[ compile-fail time_point/not_duration_fail.cpp : : time_point_not_duration_f ]
[ chrono-run-header2 time_point/arithmetic_pass.cpp : time_point_arithmetic_p ]
[ chrono-run-header2 time_point/arithmetic_ext_pass.cpp : time_point_arithmetic_ext_p ]
[ chrono-run-header2 time_point/time_point_cast_pass.cpp : time_point_time_point_cast_p ]
[ compile-fail time_point/time_point_cast_int_fail.cpp : : time_point_time_point_cast_int_f ]
[ chrono-run-header2 time_point/comparisons_pass.cpp : time_point_comparisons_p ]
[ compile-fail time_point/comparisons/equal_fail.cpp : : time_point_equal_f ]
[ compile-fail time_point/comparisons/less_fail.cpp : : time_point_less_f ]
[ chrono-run-header2 time_point/constructor_pass.cpp : time_point_constructor_p ]
[ compile-fail time_point/cons/implicit_fail.cpp : : time_point_implicit_f ]
[ compile-fail time_point/cons/non_implicit_convertible_duration_fail.cpp : : time_point_non_implicit_convertible_duration_f ]
[ chrono-run-header2 time_point/min_max_pass.cpp : time_point_min_max_p ]
;
test-suite "clock"
:
[ chrono-run2-mt clock/clock_pass.cpp : clock_clock_p ]
[ chrono-run2-mt one_obj.cpp another_obj.cpp : two_obj_p ]
;
test-suite "io_ex"
:
[ chrono-v1-v2-run ../example/io_ex1.cpp ]
[ chrono-v1-v2-run-header ../example/io_ex2.cpp ]
[ chrono-v1-v2-run ../example/io_ex3.cpp ]
[ chrono-v1-v2-run ../example/io_ex4.cpp ]
[ chrono-v1-v2-run ../example/io_ex5.cpp ]
[ chrono-v1-v2-run ../example/french.cpp ]
;
test-suite "io"
:
[ chrono-v1-v2-run-header io/duration_input.cpp ]
[ chrono-v1-v2-run-header io/duration_output.cpp ]
[ chrono-v1-v2-run-header io/time_point_input.cpp ]
[ chrono-v1-v2-run-header io/time_point_output.cpp ]
[ chrono-run test_7868.cpp ]
[ chrono-run test_11006.cpp ]
[ chrono-run test_11012.cpp ]
[ chrono-runXXX test_12176.cpp ]
;
test-suite "win32"
:
[ chrono-run win32_test.cpp ]
;
explicit ts_ ;
test-suite ts_
:
#[ chrono-run test_7868.cpp ]
#[ chrono-run test_9337.cpp ]
#[ chrono-run test_10778.cpp ]
[ chrono-run test_10631.cpp ]
;

19
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/another_obj.cpp vendored Executable file
View File

@@ -0,0 +1,19 @@
// boost win32_test.cpp -----------------------------------------------------//
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#include <iostream>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
void another() {
boost::chrono::steady_clock::time_point t1=boost::chrono::steady_clock::now();
boost::chrono::steady_clock::time_point t2=boost::chrono::steady_clock::now();
std::cout << t2-t1 << std::endl;
return ;
}

30
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/clock.h vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef CLOCK_H
#define CLOCK_H
#include <boost/chrono/chrono.hpp>
class Clock
{
typedef boost::chrono::nanoseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef boost::chrono::time_point<Clock, duration> time_point;
static const bool is_steady = false;
static time_point now();
};
#endif // CLOCK_H

201
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/clock/clock_pass.cpp vendored Executable file
View File

@@ -0,0 +1,201 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Copyright (c) Microsoft Corporation 2014
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/type_traits/is_same.hpp>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/process_cpu_clocks.hpp>
#include <boost/chrono/thread_clock.hpp>
#include <boost/system/system_error.hpp>
#include <boost/detail/lightweight_test.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
template <typename Clock>
void check_clock_invariants()
{
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Clock::rep, typename Clock::duration::rep>::value), NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Clock::period, typename Clock::duration::period>::value), NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<typename Clock::duration, typename Clock::time_point::duration>::value), NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT(Clock::is_steady || !Clock::is_steady, NOTHING, ());
// to be replaced by has static member bool is_steady
}
template <typename Clock>
void check_clock_now()
{
typename Clock::time_point t1 = Clock::now();
(void)t1;
}
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
template <typename Clock>
void check_clock_now_ec()
{
boost::system::error_code ec;
typename Clock::time_point t1 = Clock::now(ec);
(void)t1;
BOOST_TEST(ec.value()==0);
}
template <typename Clock>
void check_clock_now_throws()
{
typename Clock::time_point t1 = Clock::now(boost::throws());
(void)t1;
}
#ifndef BOOST_NO_EXCEPTIONS
template <typename Clock>
void check_clock_now_err(int err)
{
Clock::set_errno(err);
try {
typename Clock::time_point t1 = Clock::now();
} catch (boost::system::system_error& ex) {
BOOST_TEST(ex.code().value()==err);
// BOOST_TEST(ex.code().category() == ::boost::system::system_category());
// BOOST_TEST(std::string(ex.what()) == std::string("errored_clock"));
}
Clock::set_errno(0);
}
#endif
template <typename Clock>
void check_clock_now_ec_err(int err)
{
Clock::set_errno(err);
boost::system::error_code ec;
typename Clock::time_point t1 = Clock::now(ec);
BOOST_TEST(ec.value()==err);
// BOOST_TEST(ec.category() == ::boost::system::system_category());
Clock::set_errno(0);
}
#ifndef BOOST_NO_EXCEPTIONS
template <typename Clock>
void check_clock_now_throws_err(int err)
{
Clock::set_errno(err);
try {
typename Clock::time_point t1 = Clock::now(boost::throws());
BOOST_TEST(0&&"exception not thown");
} catch (boost::system::system_error& ex) {
BOOST_TEST(ex.code().value()==err);
// BOOST_TEST(ex.code().category() == ::boost::system::system_category());
// BOOST_TEST(std::string(ex.what()) == std::string("errored_clock"));
}
Clock::set_errno(0);
}
#endif
#endif
int main()
{
check_clock_invariants<boost::chrono::high_resolution_clock>();
check_clock_now<boost::chrono::high_resolution_clock>();
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
check_clock_invariants<boost::chrono::steady_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::steady_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::steady_clock>();
#endif
check_clock_invariants<boost::chrono::system_clock>();
BOOST_CHRONO_STATIC_ASSERT(!boost::chrono::system_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::system_clock>();
{
typedef boost::chrono::system_clock C;
C::time_point t1 = C::from_time_t(C::to_time_t(C::now()));
(void)t1;
}
{
typedef boost::chrono::system_clock C;
std::time_t t1 = C::to_time_t(C::now());
(void)t1;
}
{
BOOST_TEST((boost::chrono::system_clock::duration::min)() <
boost::chrono::system_clock::duration::zero());
}
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
check_clock_invariants<boost::chrono::thread_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::thread_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::thread_clock>();
#endif
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
check_clock_invariants<boost::chrono::process_real_cpu_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::process_real_cpu_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::process_real_cpu_clock>();
#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
check_clock_invariants<boost::chrono::process_user_cpu_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::process_user_cpu_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::process_user_cpu_clock>();
check_clock_invariants<boost::chrono::process_system_cpu_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::process_system_cpu_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::process_system_cpu_clock>();
check_clock_invariants<boost::chrono::process_cpu_clock>();
BOOST_CHRONO_STATIC_ASSERT(boost::chrono::process_cpu_clock::is_steady, NOTHING, ());
check_clock_now<boost::chrono::process_cpu_clock>();
#endif
#endif
#if !defined BOOST_CHRONO_DONT_PROVIDE_HYBRID_ERROR_HANDLING
check_clock_now_ec<boost::chrono::high_resolution_clock>();
check_clock_now_throws<boost::chrono::high_resolution_clock>();
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
check_clock_now_ec<boost::chrono::steady_clock>();
check_clock_now_throws<boost::chrono::steady_clock>();
#endif
check_clock_now_ec<boost::chrono::system_clock>();
check_clock_now_throws<boost::chrono::system_clock>();
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
check_clock_now_ec<boost::chrono::thread_clock>();
check_clock_now_throws<boost::chrono::thread_clock>();
#endif
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
check_clock_now_ec<boost::chrono::process_real_cpu_clock>();
check_clock_now_throws<boost::chrono::process_real_cpu_clock>();
#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
check_clock_now_ec<boost::chrono::process_user_cpu_clock>();
check_clock_now_throws<boost::chrono::process_user_cpu_clock>();
check_clock_now_ec<boost::chrono::process_system_cpu_clock>();
check_clock_now_throws<boost::chrono::process_system_cpu_clock>();
check_clock_now_ec<boost::chrono::process_cpu_clock>();
check_clock_now_throws<boost::chrono::process_cpu_clock>();
#endif
#endif
#endif
return boost::report_errors();
}

62
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/clock/errored_clock.hpp vendored Executable file
View File

@@ -0,0 +1,62 @@
// errored_clock.hpp --------------------------------------------------------------//
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef BOOST_CHRONO_ERRORED_CLOCKS_HPP
#define BOOST_CHRONO_ERRORED_CLOCKS_HPP
#include <boost/chrono/config.hpp>
#include <boost/chrono/duration.hpp>
#include <boost/chrono/time_point.hpp>
#include <boost/system/error_code.hpp>
#include <boost/system/system_error.hpp>
#include <boost/throw_exception.hpp>
#include <boost/chrono/detail/system.hpp>
class errored_clock
{
public:
typedef boost::chrono::nanoseconds duration;
typedef duration::rep rep;
typedef duration::period period;
typedef boost::chrono::time_point<errored_clock> time_point;
static const bool is_steady = true;
static int errno_;
static void set_errno(int err) {
errno_=err;
}
// throws on error
static time_point now() {
boost::throw_exception(
boost::system::system_error(
errno_,
::boost::system::system_category(),
"errored_clock"
)
);
return time_point();
}
// never throws and set ec
static time_point now(boost::system::error_code & ec) {
if (::boost::chrono::is_throws(ec))
{
boost::throw_exception(
boost::system::system_error(
errno_,
::boost::system::system_category(),
"errored_clock"
)
);
}
ec.assign( errno_, ::boost::system::system_category() );
return time_point();
};
};
int errored_clock::errno_;
#endif

350
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/arithmetic_pass.cpp vendored Executable file
View File

@@ -0,0 +1,350 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/detail/lightweight_test.hpp>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
// Default construct
{
//BOOST_CONSTEXPR
boost::chrono::minutes m;
//BOOST_CONSTEXPR_ASSERT(m.count() == 0);
(void)m;
}
// UNARY PLUS
{
boost::chrono::minutes m(3);
boost::chrono::minutes m2 = +m;
BOOST_TEST(m.count() == m2.count());
}
{
BOOST_CONSTEXPR boost::chrono::minutes m(3);
BOOST_CONSTEXPR boost::chrono::minutes m2(+m);
BOOST_CONSTEXPR_ASSERT(m.count() == m2.count());
}
// UNARY MINUS
{
boost::chrono::minutes m(3);
boost::chrono::minutes m2 = -m;
BOOST_TEST(m2.count() == -m.count());
}
{
BOOST_CONSTEXPR boost::chrono::minutes m(3);
BOOST_CONSTEXPR boost::chrono::minutes m2 = -m;
BOOST_CONSTEXPR_ASSERT(m2.count() == -m.count());
}
// PRE INCREMENT
{
boost::chrono::hours h(3);
boost::chrono::hours& href = ++h;
BOOST_TEST(&href == &h);
BOOST_TEST(h.count() == 4);
}
// POST INCREMENT
{
boost::chrono::hours h(3);
boost::chrono::hours h2 = h++;
BOOST_TEST(h.count() == 4);
BOOST_TEST(h2.count() == 3);
}
// PRE DECREMENT
{
boost::chrono::hours h(3);
boost::chrono::hours& href = --h;
BOOST_TEST(&href == &h);
BOOST_TEST(h.count() == 2);
}
// POST DECREMENT
{
boost::chrono::hours h(3);
boost::chrono::hours h2 = h--;
BOOST_TEST(h.count() == 2);
BOOST_TEST(h2.count() == 3);
}
// PLUS ASSIGN
{
boost::chrono::seconds s(3);
s += boost::chrono::seconds(2);
BOOST_TEST(s.count() == 5);
s += boost::chrono::minutes(2);
BOOST_TEST(s.count() == 125);
}
// MINUS ASSIGN
{
boost::chrono::seconds s(3);
s -= boost::chrono::seconds(2);
BOOST_TEST(s.count() == 1);
s -= boost::chrono::minutes(2);
BOOST_TEST(s.count() == -119);
}
// TIMES ASSIGN
{
boost::chrono::nanoseconds ns(3);
ns *= 5;
BOOST_TEST(ns.count() == 15);
}
// DIVIDE ASSIGN
{
boost::chrono::nanoseconds ns(15);
ns /= 5;
BOOST_TEST(ns.count() == 3);
}
// MODULUS ASSIGN duration
{
boost::chrono::microseconds us(11);
boost::chrono::microseconds us2(3);
us %= us2;
BOOST_TEST(us.count() == 2);
us %= boost::chrono::milliseconds(3);
BOOST_TEST(us.count() == 2);
}
// MODULUS ASSIGN Rep
{
boost::chrono::microseconds us(11);
us %= 3;
BOOST_TEST(us.count() == 2);
}
// PLUS
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(5);
boost::chrono::seconds r = s1 + s2;
BOOST_TEST(r.count() == 8);
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(5);
BOOST_CONSTEXPR boost::chrono::seconds r = s1 + s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 8);
}
{
boost::chrono::seconds s1(3);
boost::chrono::microseconds s2(5);
boost::chrono::microseconds r = s1 + s2;
BOOST_TEST(r.count() == 3000005);
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(5);
BOOST_CONSTEXPR boost::chrono::microseconds r = s1 + s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 3000005);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 + s2;
BOOST_TEST(r.count() == 75);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 + s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 75);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
boost::chrono::duration<double, boost::ratio<1, 15> > r = s1 + s2;
BOOST_TEST(r.count() == 75);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<1, 15> > r = s1 + s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 75);
}
// MINUS
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(5);
boost::chrono::seconds r = s1 - s2;
BOOST_TEST(r.count() == -2);
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(5);
BOOST_CONSTEXPR boost::chrono::seconds r = s1 - s2;
BOOST_CONSTEXPR_ASSERT(r.count() == -2);
}
{
boost::chrono::seconds s1(3);
boost::chrono::microseconds s2(5);
boost::chrono::microseconds r = s1 - s2;
BOOST_TEST(r.count() == 2999995);
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(5);
BOOST_CONSTEXPR boost::chrono::microseconds r = s1 - s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 2999995);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 - s2;
BOOST_TEST(r.count() == -15);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 - s2;
BOOST_CONSTEXPR_ASSERT(r.count() == -15);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
boost::chrono::duration<double, boost::ratio<1, 15> > r = s1 - s2;
BOOST_TEST(r.count() == -15);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(3);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<1, 15> > r = s1 - s2;
BOOST_CONSTEXPR_ASSERT(r.count() == -15);
}
// TIMES rep
{
boost::chrono::nanoseconds ns(3);
boost::chrono::nanoseconds ns2 = ns * 5;
BOOST_TEST(ns2.count() == 15);
boost::chrono::nanoseconds ns3 = 6 * ns2;
BOOST_TEST(ns3.count() == 90);
}
{
BOOST_CONSTEXPR boost::chrono::nanoseconds ns(3);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2 = ns * 5;
BOOST_CONSTEXPR_ASSERT(ns2.count() == 15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns3 = 6 * ns2;
BOOST_CONSTEXPR_ASSERT(ns3.count() == 90);
}
// DIVIDE duration
{
boost::chrono::nanoseconds ns1(15);
boost::chrono::nanoseconds ns2(5);
BOOST_TEST(ns1 / ns2 == 3);
}
{
BOOST_CONSTEXPR boost::chrono::nanoseconds ns1(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2(5);
BOOST_CONSTEXPR_ASSERT(ns1 / ns2 == 3);
}
{
boost::chrono::microseconds us1(15);
boost::chrono::nanoseconds ns2(5);
BOOST_TEST(us1 / ns2 == 3000);
}
{
BOOST_CONSTEXPR boost::chrono::microseconds us1(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2(5);
BOOST_CONSTEXPR_ASSERT(us1 / ns2 == 3000);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(30);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
BOOST_TEST(s1 / s2 == 6);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(30);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(5);
BOOST_CONSTEXPR_ASSERT(s1 / s2 == 6);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(30);
boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
//BOOST_TEST(s1 / s2 == 20. / 3);
BOOST_TEST(3 * s1 == 20 * s2);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(30);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 5> > s2(5);
//BOOST_CONSTEXPR_ASSERT(s1 / s2 == 20. / 3);
BOOST_TEST(3 * s1 == 20 * s2);
}
// DIVIDE rep
{
boost::chrono::nanoseconds ns(15);
boost::chrono::nanoseconds ns2 = ns / 5;
BOOST_TEST(ns2.count() == 3);
}
{
BOOST_CONSTEXPR boost::chrono::nanoseconds ns(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2 = ns / 5;
BOOST_CONSTEXPR_ASSERT(ns2.count() == 3);
}
// MODULUS duration
{
boost::chrono::nanoseconds ns1(15);
boost::chrono::nanoseconds ns2(6);
boost::chrono::nanoseconds r = ns1 % ns2;
BOOST_TEST(r.count() == 3);
}
{
BOOST_CONSTEXPR boost::chrono::nanoseconds ns1(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2(6);
BOOST_CONSTEXPR boost::chrono::nanoseconds r = ns1 % ns2;
BOOST_CONSTEXPR_ASSERT(r.count() == 3);
}
{
boost::chrono::microseconds us1(15);
boost::chrono::nanoseconds ns2(28);
boost::chrono::nanoseconds r = us1 % ns2;
BOOST_TEST(r.count() == 20);
}
{
BOOST_CONSTEXPR boost::chrono::microseconds us1(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2(28);
BOOST_CONSTEXPR boost::chrono::nanoseconds r = us1 % ns2;
BOOST_CONSTEXPR_ASSERT(r.count() == 20);
}
{
boost::chrono::duration<int, boost::ratio<3, 5> > s1(6);
boost::chrono::duration<int, boost::ratio<2, 3> > s2(3);
boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 % s2;
BOOST_TEST(r.count() == 24);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s1(6);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s2(3);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<1, 15> > r = s1 % s2;
BOOST_CONSTEXPR_ASSERT(r.count() == 24);
}
// MODULUS rep
{
boost::chrono::nanoseconds ns(15);
boost::chrono::nanoseconds ns2 = ns % 6;
BOOST_TEST(ns2.count() == 3);
}
{
BOOST_CONSTEXPR boost::chrono::nanoseconds ns(15);
BOOST_CONSTEXPR boost::chrono::nanoseconds ns2 = ns % 6;
BOOST_CONSTEXPR_ASSERT(ns2.count() == 3);
}
return boost::report_errors();
}

222
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/comparisons_pass.cpp vendored Executable file
View File

@@ -0,0 +1,222 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/detail/lightweight_test.hpp>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(3);
BOOST_TEST(s1 == s2);
BOOST_TEST(! (s1 != s2));
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(3);
BOOST_CONSTEXPR_ASSERT(s1 == s2);
BOOST_CONSTEXPR_ASSERT(!(s1 != s2));
}
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(4);
BOOST_TEST(! (s1 == s2));
BOOST_TEST(s1 != s2);
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(4);
BOOST_CONSTEXPR_ASSERT(! (s1 == s2));
BOOST_CONSTEXPR_ASSERT(s1 != s2);
}
{
boost::chrono::milliseconds s1(3);
boost::chrono::microseconds s2(3000);
BOOST_TEST(s1 == s2);
BOOST_TEST(! (s1 != s2));
}
{
BOOST_CONSTEXPR boost::chrono::milliseconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(3000);
BOOST_CONSTEXPR_ASSERT(s1 == s2);
BOOST_CONSTEXPR_ASSERT(! (s1 != s2));
}
{
boost::chrono::milliseconds s1(3);
boost::chrono::microseconds s2(4000);
BOOST_TEST(! (s1 == s2));
BOOST_TEST(s1 != s2);
}
{
BOOST_CONSTEXPR boost::chrono::milliseconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(4000);
BOOST_CONSTEXPR_ASSERT(! (s1 == s2));
BOOST_CONSTEXPR_ASSERT(s1 != s2);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(10);
BOOST_TEST(s1 == s2);
BOOST_TEST(! (s1 != s2));
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(10);
BOOST_CONSTEXPR_ASSERT(s1 == s2);
BOOST_CONSTEXPR_ASSERT(! (s1 != s2));
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(10);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(9);
BOOST_TEST(! (s1 == s2));
BOOST_TEST(s1 != s2);
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(10);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(9);
BOOST_CONSTEXPR_ASSERT(! (s1 == s2));
BOOST_CONSTEXPR_ASSERT(s1 != s2);
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
boost::chrono::duration<double, boost::ratio<3, 5> > s2(10);
BOOST_TEST(s1 == s2);
BOOST_TEST(! (s1 != s2));
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 5> > s2(10);
BOOST_CONSTEXPR_ASSERT(s1 == s2);
BOOST_CONSTEXPR_ASSERT(! (s1 != s2));
}
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(3);
BOOST_TEST(! (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST( (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(3);
BOOST_CONSTEXPR_ASSERT(! (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT( (s1 >= s2));
}
{
boost::chrono::seconds s1(3);
boost::chrono::seconds s2(4);
BOOST_TEST( (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST(! (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::seconds s1(3);
BOOST_CONSTEXPR boost::chrono::seconds s2(4);
BOOST_CONSTEXPR_ASSERT( (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT(! (s1 >= s2));
}
{
boost::chrono::milliseconds s1(3);
boost::chrono::microseconds s2(3000);
BOOST_TEST(! (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST( (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::milliseconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(3000);
BOOST_CONSTEXPR_ASSERT(! (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT( (s1 >= s2));
}
{
boost::chrono::milliseconds s1(3);
boost::chrono::microseconds s2(4000);
BOOST_TEST( (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST(! (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::milliseconds s1(3);
BOOST_CONSTEXPR boost::chrono::microseconds s2(4000);
BOOST_CONSTEXPR_ASSERT( (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT(! (s1 >= s2));
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(10);
BOOST_TEST(! (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST( (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(10);
BOOST_CONSTEXPR_ASSERT(! (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT( (s1 >= s2));
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(10);
boost::chrono::duration<int, boost::ratio<3, 5> > s2(9);
BOOST_TEST(! (s1 < s2));
BOOST_TEST( (s1 > s2));
BOOST_TEST(! (s1 <= s2));
BOOST_TEST( (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(10);
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 5> > s2(9);
BOOST_CONSTEXPR_ASSERT(! (s1 < s2));
BOOST_CONSTEXPR_ASSERT( (s1 > s2));
BOOST_CONSTEXPR_ASSERT(! (s1 <= s2));
BOOST_CONSTEXPR_ASSERT( (s1 >= s2));
}
{
boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
boost::chrono::duration<double, boost::ratio<3, 5> > s2(10);
BOOST_TEST(! (s1 < s2));
BOOST_TEST(! (s1 > s2));
BOOST_TEST( (s1 <= s2));
BOOST_TEST( (s1 >= s2));
}
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<2, 3> > s1(9);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 5> > s2(10);
BOOST_CONSTEXPR_ASSERT(! (s1 < s2));
BOOST_CONSTEXPR_ASSERT(! (s1 > s2));
BOOST_CONSTEXPR_ASSERT( (s1 <= s2));
BOOST_CONSTEXPR_ASSERT( (s1 >= s2));
}
return boost::report_errors();
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/cons/convert_float_to_int_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// conversions from floating point to integral durations disallowed
#include <boost/chrono/duration.hpp>
void test()
{
boost::chrono::duration<double> d;
boost::chrono::duration<int> i = d;
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/cons/convert_inexact_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// inexact conversions disallowed for integral reps
#include <boost/chrono/duration.hpp>
void test()
{
boost::chrono::microseconds us(1);
boost::chrono::milliseconds ms = us;
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/cons/implicit_constructot_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// test for explicit
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<int> d = 1;
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/cons/non_implicit_convertible_rep_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// Rep2 shall be implicitly convertible to rep
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<Rep> d(1);
}

21
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/cons/treat_as_floating_point_Rep2_true_fail.cpp vendored Executable file
View File

@@ -0,0 +1,21 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// treat_as_floating_point<Rep2>::value must be false
#include <boost/chrono/duration.hpp>
void test()
{
boost::chrono::duration<int> d(1.);
}

134
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/constructor_pass.cpp vendored Executable file
View File

@@ -0,0 +1,134 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/detail/lightweight_test.hpp>
#include "../rep.h"
#include <iostream>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
template <class D>
void
check_default()
{
{
D d;
BOOST_TEST(d.count() == typename D::rep());
}
}
template <class D>
void
check_constexpr()
{
BOOST_CONSTEXPR D d(0);
BOOST_CONSTEXPR_ASSERT(d.count() == typename D::rep());
}
template <class D, class R>
void
check_from_rep(R r)
{
{
D d(r);
BOOST_TEST(d.count() == r);
}
}
int main()
{
// exact conversions allowed for integral reps
{
boost::chrono::milliseconds ms(1);
boost::chrono::microseconds us = ms;
BOOST_TEST(us.count() == 1000);
{
BOOST_CONSTEXPR boost::chrono::milliseconds ms(1);
BOOST_CONSTEXPR boost::chrono::microseconds us = ms;
BOOST_CONSTEXPR_ASSERT(us.count() == 1000);
}
}
// inexact conversions allowed for floating point reps
{
boost::chrono::duration<double, boost::micro> us(1);
boost::chrono::duration<double, boost::milli> ms = us;
BOOST_TEST(ms.count() == 1./1000);
{
BOOST_CONSTEXPR boost::chrono::duration<double, boost::micro> us(1);
BOOST_CONSTEXPR boost::chrono::duration<double, boost::milli> ms = us;
BOOST_CONSTEXPR_ASSERT(ms.count() == 1./1000);
}
}
// Convert int to float
{
boost::chrono::duration<int> i(3);
boost::chrono::duration<double> d = i;
BOOST_TEST(d.count() == 3);
{
BOOST_CONSTEXPR boost::chrono::duration<int> i(3);
BOOST_CONSTEXPR boost::chrono::duration<double> d = i;
BOOST_CONSTEXPR_ASSERT(d.count() == 3);
}
}
// default constructor
{
check_default<boost::chrono::duration<Rep> >();
}
{
check_constexpr<boost::chrono::duration<int> >();
}
// constructor from rep
{
check_from_rep<boost::chrono::duration<int> >(5);
{
BOOST_CONSTEXPR boost::chrono::duration<int> d(5);
BOOST_CONSTEXPR_ASSERT(d.count() == 5);
}
check_from_rep<boost::chrono::duration<int, boost::ratio<3, 2> > >(5);
{
BOOST_CONSTEXPR boost::chrono::duration<int, boost::ratio<3, 2> > d(5);
BOOST_CONSTEXPR_ASSERT(d.count() == 5);
}
check_from_rep<boost::chrono::duration<Rep, boost::ratio<3, 2> > >(Rep(3));
{
BOOST_CONSTEXPR boost::chrono::duration<Rep, boost::ratio<3, 2> > d(Rep(3));
BOOST_CONSTEXPR_ASSERT(d.count() == Rep(3));
}
check_from_rep<boost::chrono::duration<double, boost::ratio<2, 3> > >(5.5);
{
BOOST_CONSTEXPR boost::chrono::duration<double, boost::ratio<3, 2> > d(5.5);
BOOST_CONSTEXPR_ASSERT(d.count() == 5.5);
}
}
// constructor from other rep
{
boost::chrono::duration<double> d(5);
BOOST_TEST(d.count() == 5);
{
BOOST_CONSTEXPR boost::chrono::duration<double> d(5);
BOOST_CONSTEXPR_ASSERT(d.count() == 5);
}
}
return boost::report_errors();
}

29
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/default_ratio_pass.cpp vendored Executable file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// Test default template arg:
// template <class Rep, class Period = ratio<1>>
// class duration;
#include <boost/chrono/duration.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<
boost::chrono::duration<int, boost::ratio<1> >,
boost::chrono::duration<int>
>::value), NOTHING, ());

21
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/duration_cast_int_fail.cpp vendored Executable file
View File

@@ -0,0 +1,21 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// ToDuration must be an instantiation of duration.
#include <boost/chrono/duration.hpp>
void test()
{
boost::chrono::duration_cast<int>(boost::chrono::milliseconds(3));
}

59
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/duration_cast_pass.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/type_traits.hpp>
#include <boost/detail/lightweight_test.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
template <class ToDuration, class FromDuration>
void
test(const FromDuration& f, const ToDuration& d)
{
//~ #if defined(BOOST_NO_CXX11_DECLTYPE)
//~ typedef BOOST_TYPEOF_TPL(boost::chrono::duration_cast<ToDuration>(f)) R;
//~ #else
//~ typedef decltype(boost::chrono::duration_cast<ToDuration>(f)) R;
//~ #endif
//~ BOOST_CHRONO_STATIC_ASSERT((boost::is_same<R, ToDuration>::value), NOTHING, (R, ToDuration));
BOOST_TEST(boost::chrono::duration_cast<ToDuration>(f) == d);
}
int main()
{
test(boost::chrono::milliseconds(7265000), boost::chrono::hours(2));
test(boost::chrono::milliseconds(7265000), boost::chrono::minutes(121));
test(boost::chrono::milliseconds(7265000), boost::chrono::seconds(7265));
test(boost::chrono::milliseconds(7265000), boost::chrono::milliseconds(7265000));
test(boost::chrono::milliseconds(7265000), boost::chrono::microseconds(7265000000LL));
test(boost::chrono::milliseconds(7265000), boost::chrono::nanoseconds(7265000000000LL));
test(boost::chrono::milliseconds(7265000),
boost::chrono::duration<double, boost::ratio<3600> >(7265./3600));
test(boost::chrono::duration<int, boost::ratio<2, 3> >(9),
boost::chrono::duration<int, boost::ratio<3, 5> >(10));
{
BOOST_CONSTEXPR boost::chrono::hours h = boost::chrono::duration_cast<boost::chrono::hours>(boost::chrono::milliseconds(7265000));
BOOST_CONSTEXPR_ASSERT(h.count() == 2);
}
return boost::report_errors();
}

24
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/duration_duration_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// If a program instantiates duration with a duration type for the template
// argument Rep a diagnostic is required.
#include <boost/chrono/duration.hpp>
void test()
{
typedef boost::chrono::duration<boost::chrono::milliseconds> D;
D d;
}

76
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/duration_values_pass.cpp vendored Executable file
View File

@@ -0,0 +1,76 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/detail/lightweight_test.hpp>
#include "../rep.h"
#if defined BOOST_NO_CXX11_NUMERIC_LIMITS || defined BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
template <class D>
void check_max()
{
typedef typename D::rep Rep;
Rep max_rep = (boost::chrono::duration_values<Rep>::max)();
BOOST_TEST((D::max)().count() == max_rep);
{
typedef typename D::rep Rep;
BOOST_CHRONO_LIB_CONSTEXPR Rep max_rep = (boost::chrono::duration_values<Rep>::max)();
BOOST_CONSTEXPR_ASSERT((D::max)().count() == max_rep);
}
}
template <class D>
void check_min()
{
typedef typename D::rep Rep;
Rep min_rep = (boost::chrono::duration_values<Rep>::min)();
BOOST_TEST((D::min)().count() == min_rep);
{
typedef typename D::rep Rep;
BOOST_CHRONO_LIB_CONSTEXPR Rep min_rep = (boost::chrono::duration_values<Rep>::min)();
BOOST_CONSTEXPR_ASSERT((D::min)().count() == min_rep);
}
}
template <class D>
void check_zero()
{
typedef typename D::rep Rep;
Rep zero_rep = boost::chrono::duration_values<Rep>::zero();
BOOST_TEST(D::zero().count() == zero_rep);
{
typedef typename D::rep Rep;
BOOST_CONSTEXPR Rep zero_rep = boost::chrono::duration_values<Rep>::zero();
BOOST_CONSTEXPR_ASSERT(D::zero().count() == zero_rep);
}
}
int main()
{
check_max<boost::chrono::duration<int> >();
check_max<boost::chrono::duration<Rep> >();
check_min<boost::chrono::duration<int> >();
check_min<boost::chrono::duration<Rep> >();
check_zero<boost::chrono::duration<int> >();
check_zero<boost::chrono::duration<Rep> >();
return boost::report_errors();
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/nonmember/divide_rep2_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<Rep> d(Rep(15));
d = d / 5;
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/nonmember/modulus_rep2_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<Rep> d(Rep(15));
d = d % 5;
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/nonmember/times_rep2_lhs_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<Rep> d;
d = 5 * d;
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/nonmember/times_rep2_rhs_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include "../../rep.h"
void test()
{
boost::chrono::duration<Rep> d;
d = d * 5;
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/positive_num_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// Period::num must be positive, diagnostic required.
#include <boost/chrono/duration.hpp>
void test()
{
typedef boost::chrono::duration<int, boost::ratio<5, -1> > D;
D d;
}

29
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/ratio_alias_pass.cpp vendored Executable file
View File

@@ -0,0 +1,29 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// Period shall be a specialization of ratio, diagnostic required.
#include <boost/chrono/duration.hpp>
void test()
{
typedef boost::chrono::duration<int,
boost::ratio_add<
boost::ratio<1,2>,
boost::ratio<1,3>
>
> D;
D d;
(void)d;
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/ratio_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// Period shall be a specialization of ratio, diagnostic required.
#include <boost/chrono/duration.hpp>
void test()
{
typedef boost::chrono::duration<int, int > D;
D d;
}

105
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/rounding_pass.cpp vendored Executable file
View File

@@ -0,0 +1,105 @@
// Copyright 2013 Krzysztof Czainski
// Copyright 2013 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// (See accompanying file LICENSE_1_0.txt or copy at
// http://www.boost.org/LICENSE_1_0.txt)
/*
* @file chrono_rounding.cpp
*
* @since 2013-11-22
* @author Krzysztof Czainski <1czajnik@gmail.com>
*/
#include <boost/cstdint.hpp>
#include <boost/chrono/ceil.hpp>
#include <boost/chrono/floor.hpp>
#include <boost/chrono/round.hpp>
#include <boost/chrono/chrono_io.hpp>
#include <boost/detail/lightweight_test.hpp>
using namespace boost::chrono;
void test_floor()
{
BOOST_TEST_EQ( seconds(-2), floor<seconds>( milliseconds(-2000) ) );
BOOST_TEST_EQ( seconds(-2), floor<seconds>( milliseconds(-1999) ) );
BOOST_TEST_EQ( seconds(-2), floor<seconds>( milliseconds(-1001) ) );
BOOST_TEST_EQ( seconds(-1), floor<seconds>( milliseconds(-1000) ) );
BOOST_TEST_EQ( seconds(-1), floor<seconds>( milliseconds(-999) ) );
BOOST_TEST_EQ( seconds(-1), floor<seconds>( milliseconds(-1) ) );
BOOST_TEST_EQ( seconds(0), floor<seconds>( milliseconds(0) ) );
BOOST_TEST_EQ( seconds(0), floor<seconds>( milliseconds(1) ) );
BOOST_TEST_EQ( seconds(0), floor<seconds>( milliseconds(999) ) );
BOOST_TEST_EQ( seconds(1), floor<seconds>( milliseconds(1000) ) );
BOOST_TEST_EQ( seconds(1), floor<seconds>( milliseconds(1001) ) );
BOOST_TEST_EQ( seconds(1), floor<seconds>( milliseconds(1999) ) );
BOOST_TEST_EQ( seconds(2), floor<seconds>( milliseconds(2000) ) );
{
// check that int32 isn't overflowed in intermediate calculations:
typedef duration<boost::int32_t> sec32;
typedef duration< boost::int32_t, boost::ratio<999,1000> > sec32_m1ms;
BOOST_TEST_EQ( sec32(-999000000), floor<sec32>( sec32_m1ms(-1000000000) ) );
BOOST_TEST_EQ( sec32( 999000000), floor<sec32>( sec32_m1ms( 1000000000) ) );
}
}
void test_ceil()
{
BOOST_TEST_EQ( seconds(-2), ceil<seconds>( milliseconds(-2000) ) );
BOOST_TEST_EQ( seconds(-1), ceil<seconds>( milliseconds(-1999) ) );
BOOST_TEST_EQ( seconds(-1), ceil<seconds>( milliseconds(-1001) ) );
BOOST_TEST_EQ( seconds(-1), ceil<seconds>( milliseconds(-1000) ) );
BOOST_TEST_EQ( seconds(0), ceil<seconds>( milliseconds(-999) ) );
BOOST_TEST_EQ( seconds(0), ceil<seconds>( milliseconds(-1) ) );
BOOST_TEST_EQ( seconds(0), ceil<seconds>( milliseconds(0) ) );
BOOST_TEST_EQ( seconds(1), ceil<seconds>( milliseconds(1) ) );
BOOST_TEST_EQ( seconds(1), ceil<seconds>( milliseconds(999) ) );
BOOST_TEST_EQ( seconds(1), ceil<seconds>( milliseconds(1000) ) );
BOOST_TEST_EQ( seconds(2), ceil<seconds>( milliseconds(1001) ) );
BOOST_TEST_EQ( seconds(2), ceil<seconds>( milliseconds(1999) ) );
BOOST_TEST_EQ( seconds(2), ceil<seconds>( milliseconds(2000) ) );
{
// check that int32 isn't overflowed in intermediate calculations:
typedef duration<boost::int32_t> sec32;
typedef duration< boost::int32_t, boost::ratio<999,1000> > sec32_m1ms;
BOOST_TEST_EQ( sec32(-999000000), ceil<sec32>( sec32_m1ms(-1000000000) ) );
BOOST_TEST_EQ( sec32( 999000000), ceil<sec32>( sec32_m1ms( 1000000000) ) );
}
}
void test_round()
{
// to even on tie
BOOST_TEST_EQ( seconds(-2), round<seconds>( milliseconds(-2000) ) );
BOOST_TEST_EQ( seconds(-2), round<seconds>( milliseconds(-1500) ) );
BOOST_TEST_EQ( seconds(-1), round<seconds>( milliseconds(-1499) ) );
BOOST_TEST_EQ( seconds(-1), round<seconds>( milliseconds(-1000) ) );
BOOST_TEST_EQ( seconds(0), round<seconds>( milliseconds(-500) ) );
BOOST_TEST_EQ( seconds(0), round<seconds>( milliseconds(-499) ) );
BOOST_TEST_EQ( seconds(0), round<seconds>( milliseconds(0) ) );
BOOST_TEST_EQ( seconds(0), round<seconds>( milliseconds(499) ) );
BOOST_TEST_EQ( seconds(0), round<seconds>( milliseconds(500) ) );
BOOST_TEST_EQ( seconds(1), round<seconds>( milliseconds(1000) ) );
BOOST_TEST_EQ( seconds(1), round<seconds>( milliseconds(1499) ) );
BOOST_TEST_EQ( seconds(2), round<seconds>( milliseconds(1500) ) );
BOOST_TEST_EQ( seconds(2), round<seconds>( milliseconds(2000) ) );
{
// check that int32 isn't overflowed in intermediate calculations:
typedef duration<boost::int32_t> sec32;
typedef duration< boost::int32_t, boost::ratio<999,1000> > sec32_m1ms;
BOOST_TEST_EQ( sec32(-999000000), round<sec32>( sec32_m1ms(-1000000000) ) );
BOOST_TEST_EQ( sec32( 999000000), round<sec32>( sec32_m1ms( 1000000000) ) );
}
}
int main()
{
test_floor();
test_ceil();
test_round();
return boost::report_errors();
}

42
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/typedefs_pass.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/duration.hpp>
#include <boost/type_traits.hpp>
#include <limits>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
template <typename D, int ExpectedDigits, typename ExpectedPeriod>
void check_duration()
{
typedef typename D::rep Rep;
typedef typename D::period Period;
BOOST_CHRONO_STATIC_ASSERT(boost::is_signed<Rep>::value, NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT(boost::is_integral<Rep>::value, NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT(std::numeric_limits<Rep>::digits >= ExpectedDigits, NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<Period, ExpectedPeriod >::value), NOTHING, ());
}
void test()
{
check_duration<boost::chrono::hours, 22, boost::ratio<3600> >();
check_duration<boost::chrono::minutes, 28, boost::ratio<60> >();
check_duration<boost::chrono::seconds, 34, boost::ratio<1> >();
check_duration<boost::chrono::milliseconds, 44, boost::milli >();
check_duration<boost::chrono::microseconds, 54, boost::micro >();
check_duration<boost::chrono::nanoseconds, 63, boost::nano >();
}

28
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/duration/types_pass.cpp vendored Executable file
View File

@@ -0,0 +1,28 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// duration
// Test nested types
// typedef Rep rep;
// typedef Period period;
#include <boost/chrono/duration.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
typedef boost::chrono::duration<long, boost::ratio<3, 2> > D;
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<D::rep, long>::value), NOTHING, ());
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<D::period, boost::ratio<3, 2> >::value), NOTHING, ());

19
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/intmax_c.cpp vendored Executable file
View File

@@ -0,0 +1,19 @@
// intmax_c.cpp --------------------------------------------------------------//
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/cstdint.hpp>
#ifdef INTMAX_C
#define BOOST_INTMAX_C(a) INTMAX_C(a)
#else
#define BOOST_INTMAX_C(a) a##LL
#endif
boost::intmax_t i = BOOST_INTMAX_C(1000000000);
int main() {
return (i);
}

124
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/io/duration_input.cpp vendored Executable file
View File

@@ -0,0 +1,124 @@
// Distributed under the Boost Software License, Version 1.0.
// Copyright 2011 Vicente J. Botet Escriba
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono_io.hpp>
//#include <boost/chrono/io/duration_units.hpp>
#include <sstream>
#include <boost/detail/lightweight_test.hpp>
template<typename D>
void test_good(const char* str, D res)
{
std::istringstream in(str);
D d(0);
in >> d;
BOOST_TEST(in.eof());
BOOST_TEST(!in.fail());
BOOST_TEST(d == res);
std::cout << str << " " << res << " " << d << std::endl;
}
template<typename DFail>
void test_fail(const char* str, DFail res)
{
{
std::istringstream in(str);
DFail d = DFail::zero();
in >> d;
BOOST_TEST(in.fail());
BOOST_TEST(d == DFail::zero());
std::cout << str << " " << res << " " << d << std::endl;
}
}
template<typename D>
void test_not_eof(const char* str, D res)
{
{
std::istringstream in(str);
D d = D::zero();
in >> d;
BOOST_TEST(!in.eof());
BOOST_TEST(d == res);
std::cout << str << " " << res << " " << d << std::endl;
}
}
int main()
{
using namespace boost::chrono;
using namespace boost;
test_good("5000", 5000);
std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
test_good("5000 hours", hours(5000));
std::cerr << __FILE__ << "[" << __LINE__ << "]"<< std::endl;
test_good("5000 minutes", minutes(5000));
test_good("5000 seconds", seconds(5000));
test_fail("1.0 second", seconds(1));
test_good("1.0 second", duration<float,ratio<1> >(1));
/* BUG with DURATION_GET
../../../boost/math/common_factor_rt.hpp: In function 'RingType boost::math::detail::gcd_euclidean(RingType, RingType) [with RingType = long double]':
../../../boost/math/common_factor_rt.hpp:122: instantiated from 'IntegerType boost::math::detail::gcd_integer(const IntegerType&, const IntegerType&) [with IntegerType = long double]'
../../../boost/math/common_factor_rt.hpp:240: instantiated from 'T boost::math::detail::gcd_optimal_evaluator_helper_t<T, true, true>::operator()(const T&, const T&) [with T = long double]'
../../../boost/math/common_factor_rt.hpp:290: instantiated from 'T boost::math::detail::gcd_optimal_evaluator<T>::operator()(const T&, const T&) [with T = long double]'
../../../boost/math/common_factor_rt.hpp:442: instantiated from 'T boost::math::detail::gcd_optimal(const T&, const T&) [with T = long double]'
../../../boost/math/common_factor_rt.hpp:473: instantiated from 'typename boost::math::gcd_evaluator<IntegerType>::result_type boost::math::gcd_evaluator<IntegerType>::operator()(const IntegerType&, const IntegerType&) const [with IntegerType = long double]'
../../../boost/math/common_factor_rt.hpp:505: instantiated from 'IntegerType boost::math::gcd(const IntegerType&, const IntegerType&) [with IntegerType = long double]'
../../../boost/chrono/io/duration_get.hpp:239: instantiated from 'InputIterator boost::chrono::duration_get<CharT, InputIterator>::get(InputIterator, InputIterator, std::ios_base&, std::_Ios_Iostate&, boost::chrono::duration<Rep2, Period2>&, const CharT*, const CharT*) const [with Rep = double, Period = boost::ratio<1l, 1l>, CharT = char, InputIterator = std::istreambuf_iterator<char, std::char_traits<char> >]'
../../../boost/chrono/io/duration_get.hpp:294: instantiated from 'InputIterator boost::chrono::duration_get<CharT, InputIterator>::get(InputIterator, InputIterator, std::ios_base&, std::_Ios_Iostate&, boost::chrono::duration<Rep2, Period2>&) const [with Rep = double, Period = boost::ratio<1l, 1l>, CharT = char, InputIterator = std::istreambuf_iterator<char, std::char_traits<char> >]'
../../../boost/chrono/io/duration_io.hpp:593: instantiated from 'std::basic_istream<_CharT, _Traits>& boost::chrono::operator>>(std::basic_istream<_CharT, _Traits>&, boost::chrono::duration<Rep2, Period2>&) [with CharT = char, Traits = std::char_traits<char>, Rep = double, Period = boost::ratio<1l, 1l>]'
io/duration_input.cpp:15: instantiated from 'void test_good(const char*, D) [with D = boost::chrono::duration<double, boost::ratio<1l, 1l> >]'
io/duration_input.cpp:52: instantiated from here
../../../boost/math/common_factor_rt.hpp:102: error: invalid operands of types 'long double' and 'long double' to binary 'operator%'
../../../boost/math/common_factor_rt.hpp:102: error: in evaluation of 'operator%=(long double, long double)'
../../../boost/math/common_factor_rt.hpp:106: error: invalid operands of types 'long double' and 'long double' to binary 'operator%'
../../../boost/math/common_factor_rt.hpp:106: error: in evaluation of 'operator%=(long double, long double)'
*
*/
test_good("1 second", seconds(1));
test_not_eof("1 second ", seconds(1));
test_not_eof("1 seconde", seconds(1));
test_good("1 seconds", seconds(1));
test_good("0 seconds", seconds(0));
test_good("-1 seconds", seconds(-1));
test_good("5000 milliseconds", milliseconds(5000));
test_good("5000 microseconds", microseconds(5000));
test_good("5000 nanoseconds", nanoseconds(5000));
test_good("5000 deciseconds", duration<boost::int_least64_t, deci> (5000));
test_good("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good("5000 [1/30]second", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good("5000 h", hours(5000));
#if BOOST_CHRONO_VERSION==2
test_good("5000 min", minutes(5000));
#else
test_good("5000 m", minutes(5000));
#endif
test_good("5000 s", seconds(5000));
test_good("5000 ms", milliseconds(5000));
test_good("5000 ns", nanoseconds(5000));
test_good("5000 ds", duration<boost::int_least64_t, deci> (5000));
test_good("5000 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_not_eof("5000 [1/30]ss", duration<boost::int_least64_t, ratio<1, 30> > (5000));
std::cout << __LINE__<< "*****" << std::endl;
test_good("5000 milliseconds", seconds(5));
test_good("5000 millisecond", seconds(5));
test_good("5 milliseconds", nanoseconds(5000000));
std::cout << __LINE__<< "*****" << std::endl;
test_good("4000 ms", seconds(4));
std::cout << __LINE__<< "*****" << std::endl;
test_fail("3001 ms", seconds(3));
std::cout << __LINE__<< "*****" << std::endl;
test_fail("3001 ", milliseconds(3001));
std::cout << __LINE__<< "*****" << std::endl;
test_fail("one ms", milliseconds(1));
test_fail("5000 millisecon", seconds(5));
test_not_eof("3001 ms ", milliseconds(3001));
return boost::report_errors();
}

114
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/io/duration_output.cpp vendored Executable file
View File

@@ -0,0 +1,114 @@
// Copyright 2011 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono_io.hpp>
#include <sstream>
#include <boost/detail/lightweight_test.hpp>
template<typename D>
void test_good_prefix(const char* str, D d)
{
std::ostringstream out;
out << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str);
}
template<typename D>
void test_good_symbol(const char* str, D d)
{
std::ostringstream out;
#if BOOST_CHRONO_VERSION==2
out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << d;
#else
out << boost::chrono::duration_short << d;
#endif
BOOST_TEST(out.good());
BOOST_TEST_EQ(out.str(), str);
}
#if BOOST_CHRONO_VERSION==2
template<typename D>
void test_good(const char* str, D d, boost::chrono::duration_style style)
{
std::ostringstream out;
out << boost::chrono::duration_fmt(style) << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str);
}
template<typename D>
void test_state_saver(const char* str, const char* str2, D d, boost::chrono::duration_style style)
{
std::ostringstream out;
{
boost::chrono::duration_style_io_saver ios(out);
out << boost::chrono::duration_fmt(style) << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str);
}
out << " " << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str2);
}
template<typename D>
void test_state_saver2(const char* str, const char* str2, D d, boost::chrono::duration_style style)
{
std::ostringstream out;
{
boost::chrono::duration_style_io_saver ios(out, style);
out << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str);
}
out << " " << d;
BOOST_TEST(out.good());
BOOST_TEST(out.str() == str2);
}
#endif
int main()
{
using namespace boost::chrono;
using namespace boost;
test_good_prefix("5000 hours", hours(5000));
test_good_prefix("5000 minutes", minutes(5000));
test_good_prefix("5000 seconds", seconds(5000));
test_good_prefix("0 seconds", seconds(0));
test_good_prefix("1 second", seconds(1));
test_good_prefix("-1 second", seconds(-1));
test_good_prefix("5000 milliseconds", milliseconds(5000));
test_good_prefix("5000 microseconds", microseconds(5000));
test_good_prefix("5000 nanoseconds", nanoseconds(5000));
test_good_prefix("5000 deciseconds", duration<boost::int_least64_t, deci> (5000));
test_good_prefix("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good_symbol("5000 h", hours(5000));
#if BOOST_CHRONO_VERSION==2
test_good_symbol("5000 min", minutes(5000));
#else
test_good_symbol("5000 m", minutes(5000));
#endif
test_good_symbol("5000 s", seconds(5000));
test_good_symbol("5000 ms", milliseconds(5000));
test_good_symbol("5000 ns", nanoseconds(5000));
test_good_symbol("5000 ds", duration<boost::int_least64_t, deci> (5000));
test_good_symbol("5000 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (5000));
#if BOOST_CHRONO_VERSION==2
test_good("5000 hours", hours(5000), duration_style::prefix);
test_good("5000 h", hours(5000), duration_style::symbol);
test_state_saver("5000 h", "5000 h 5000 hours", hours(5000), duration_style::symbol);
test_state_saver2("5000 h", "5000 h 5000 hours", hours(5000), duration_style::symbol);
#endif
return boost::report_errors();
}

238
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/io/time_point_input.cpp vendored Executable file
View File

@@ -0,0 +1,238 @@
// Copyright 2011 Vicente J. Botet Escriba
// Copyright (c) Microsoft Corporation 2014
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono_io.hpp>
#include <sstream>
#include <boost/detail/lightweight_test.hpp>
#include <boost/chrono/system_clocks.hpp>
#include <boost/chrono/thread_clock.hpp>
#include <boost/chrono/process_cpu_clocks.hpp>
#if 0
template <typename Clock, typename D>
void test_good(std::string str, D res)
{
typedef typename Clock::time_point clock_time_point;
typedef typename Clock::duration clock_duration;
std::istringstream in(str + boost::chrono::clock_string<Clock, char>::since());
clock_time_point tp;
in >> tp;
BOOST_TEST(in.eof());
BOOST_TEST(!in.fail());
std::cout << "Input= " << str << std::endl;
std::cout << "Expected= " << clock_time_point(boost::chrono::duration_cast<clock_duration>(res)) << std::endl;
std::cout << "Obtained= " << tp << std::endl;
BOOST_TEST( (tp == clock_time_point(boost::chrono::duration_cast<clock_duration>(res)) ));
}
#else
template <typename Clock, typename D>
void test_good(std::string str, D res)
{
typedef boost::chrono::time_point<Clock, D> clock_time_point;
//typedef typename Clock::duration clock_duration;
std::istringstream in(str + boost::chrono::clock_string<Clock, char>::since());
clock_time_point tp;
in >> tp;
BOOST_TEST(in.eof());
BOOST_TEST(!in.fail());
std::cout << "Input= " << str << std::endl;
std::cout << "Expected= " << clock_time_point(res) << std::endl;
std::cout << "Obtained= " << tp << std::endl;
BOOST_TEST( tp == clock_time_point(res) );
}
#endif
#if BOOST_CHRONO_VERSION >= 2
template <typename D>
void test_good_system_clock(std::string str, D res)
{
typedef boost::chrono::system_clock Clock;
std::istringstream in(str);
boost::chrono::time_point<Clock, D> tp;
in >> tp;
BOOST_TEST(in.eof());
BOOST_TEST(!in.fail());
std::cout << "Input= " << str << std::endl;
std::cout << "Expected= " << boost::chrono::time_point<Clock, D>(res) << std::endl;
std::cout << "Obtained= " << tp << std::endl;
std::cout << "Expected= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(boost::chrono::time_point<Clock, D>(res).time_since_epoch()).count() << std::endl;
std::cout << "Obtained= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(tp.time_since_epoch()).count() << std::endl;
BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>(res)));
}
template <typename D>
void test_good_utc_fmt_system_clock(std::string str, std::string fmt, D res)
{
typedef boost::chrono::system_clock Clock;
std::istringstream in(str);
boost::chrono::time_point<Clock, D> tp;
in >> time_fmt(boost::chrono::timezone::utc, fmt);
in >> tp;
BOOST_TEST(in.eof());
BOOST_TEST(!in.fail());
std::cout << "Input= " << str << std::endl;
std::cout << "Expected= " << boost::chrono::time_point<Clock, D>(res) << std::endl;
std::cout << "Obtained= " << tp << std::endl;
std::cout << "Expected= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(boost::chrono::time_point<Clock, D>(res).time_since_epoch()).count() << std::endl;
std::cout << "Obtained= " << boost::chrono::duration_cast<boost::chrono::nanoseconds>(tp.time_since_epoch()).count() << std::endl;
BOOST_TEST_EQ( tp , (boost::chrono::time_point<Clock, D>(res)));
}
#endif
template <typename Clock, typename D>
void test_fail(const char* str, D)
{
std::istringstream in(str + boost::chrono::clock_string<Clock, char>::since());
boost::chrono::time_point<Clock, D> tp;
in >> tp;
BOOST_TEST(in.fail());
BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
}
template <typename Clock, typename D>
void test_fail_no_epoch(const char* str, D )
{
std::istringstream in(str);
boost::chrono::time_point<Clock, D> tp;
in >> tp;
BOOST_TEST(in.fail());
BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
}
template <typename Clock, typename D>
void test_fail_epoch(const char* str, D)
{
std::istringstream in(str);
boost::chrono::time_point<Clock, D> tp;
in >> tp;
BOOST_TEST(in.fail());
BOOST_TEST( (tp == boost::chrono::time_point<Clock, D>()));
}
template <typename Clock>
void check_all()
{
using namespace boost::chrono;
using namespace boost;
test_good<Clock> ("5000 hours", hours(5000));
test_good<Clock> ("5000 minutes", minutes(5000));
test_good<Clock> ("5000 seconds", seconds(5000));
test_good<Clock> ("1 seconds", seconds(1));
test_good<Clock> ("1 second", seconds(1));
test_good<Clock> ("-1 seconds", seconds(-1));
test_good<Clock> ("0 second", seconds(0));
test_good<Clock> ("0 seconds", seconds(0));
test_good<Clock> ("5000 milliseconds", milliseconds(5000));
test_good<Clock> ("5000 microseconds", microseconds(5000));
test_good<Clock> ("5000 nanoseconds", nanoseconds(5000));
test_good<Clock> ("5000 deciseconds", duration<boost::int_least64_t, deci> (5000));
test_good<Clock> ("5000 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good<Clock> ("5000 h", hours(5000));
#if BOOST_CHRONO_VERSION >= 2
test_good<Clock>("5000 min", minutes(5000));
#else
test_good<Clock> ("5000 m", minutes(5000));
#endif
test_good<Clock> ("5000 s", seconds(5000));
test_good<Clock> ("5000 ms", milliseconds(5000));
test_good<Clock> ("5000 ns", nanoseconds(5000));
test_good<Clock> ("5000 ds", duration<boost::int_least64_t, deci> (5000));
test_good<Clock> ("5000 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good<Clock> ("5000 milliseconds", seconds(5));
test_good<Clock> ("5 milliseconds", nanoseconds(5000000));
test_good<Clock> ("4000 ms", seconds(4));
test_fail<Clock> ("3001 ms", seconds(3));
test_fail_epoch<Clock> ("3001 ms", seconds(3));
test_fail_epoch<Clock> ("3001 ms since", seconds(3));
}
#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
void check_all_process_cpu_clock()
{
using namespace boost::chrono;
using namespace boost;
//typedef process_cpu_clock Clock;
//test_good<Clock> ("{5000;0;0} nanoseconds", process_cpu_clock::duration(process_cpu_clock::times(5000,0,0)));
}
#endif
#if BOOST_CHRONO_VERSION >= 2
void check_all_system_clock()
{
using namespace boost::chrono;
using namespace boost;
test_good_system_clock ("1970-01-01 02:00:00.000000 +0000", hours(2));
test_good_system_clock ("1970-07-28 08:00:00.000000 +0000", hours(5000));
test_good_system_clock ("1970-01-04 11:20:00.000000 +0000", minutes(5000));
test_good_system_clock ("1970-01-01 01:23:20.000000 +0000", seconds(5000));
test_good_system_clock ("1970-01-01 00:00:01.000000 +0000", seconds(1));
test_good_system_clock ("1970-01-01 00:00:01.000000 +0000", seconds(1));
test_good_system_clock ("1969-12-31 23:59:59.000000 +0000", seconds(-1));
test_good_system_clock ("1970-01-01 00:00:00.000000 +0000", seconds(0));
test_good_system_clock ("1970-01-01 00:00:00.000000 +0000", seconds(0));
test_good_system_clock ("1970-01-01 00:00:05.000000 +0000", milliseconds(5000));
test_good_system_clock ("1970-01-01 00:00:00.005000 +0000", microseconds(5000));
test_good_system_clock ("1970-01-01 00:00:00.000005 +0000", nanoseconds(5000));
test_good_system_clock ("1970-01-01 00:08:20.000000 +0000", duration<boost::int_least64_t, deci> (5000));
test_good_system_clock ("1970-01-01 00:02:46.666667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (5000));
test_good_utc_fmt_system_clock ("1970-01-01 02:00:00", "%Y-%m-%d %H:%M:%S", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02:00:00", "%F %H:%M:%S", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02", "%Y-%m-%d %H", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02", "%F %H", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02:00:00", "%Y-%m-%d %T", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02:00", "%Y-%m-%d %R", hours(2));
test_good_utc_fmt_system_clock ("% 1970-01-01 02:00", "%% %Y-%m-%d %R", hours(2));
//test_good_utc_fmt_system_clock ("1970-01-01 02:00 Thursday January", "%Y-%m-%d %R %A %B", hours(2));
// test_fail<Clock> ("3001 ms", seconds(3));
// test_fail_epoch<Clock> ("3001 ms", seconds(3));
// test_fail_epoch<Clock> ("3001 ms since", seconds(3));
}
#endif
int main()
{
std::cout << "high_resolution_clock=" << std::endl;
check_all<boost::chrono::high_resolution_clock> ();
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
std::cout << "steady_clock=" << std::endl;
check_all<boost::chrono::steady_clock> ();
#endif
std::cout << "system_clock=" << std::endl;
#if BOOST_CHRONO_VERSION >= 2 && defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
check_all_system_clock();
#else
check_all<boost::chrono::system_clock> ();
#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
std::cout << "thread_clock="<< std::endl;
check_all<boost::chrono::thread_clock>();
#endif
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
std::cout << "process_real_cpu_clock=" << std::endl;
check_all<boost::chrono::process_real_cpu_clock> ();
#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
std::cout << "process_user_cpu_clock=" << std::endl;
check_all<boost::chrono::process_user_cpu_clock> ();
std::cout << "process_system_cpu_clock=" << std::endl;
check_all<boost::chrono::process_system_cpu_clock> ();
std::cout << "process_cpu_clock=" << std::endl;
//check_all_process_cpu_clock();
#endif
#endif
return boost::report_errors();
}

317
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/io/time_point_output.cpp vendored Executable file
View File

@@ -0,0 +1,317 @@
// Copyright 2011 Vicente J. Botet Escriba
// Copyright (c) Microsoft Corporation 2014
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono_io.hpp>
#include <sstream>
#include <boost/detail/lightweight_test.hpp>
#include <boost/chrono/system_clocks.hpp>
#include <boost/chrono/thread_clock.hpp>
#include <boost/chrono/process_cpu_clocks.hpp>
#include <locale>
#include <ctime>
#include <cstdio>
template <typename Clock, typename D>
void test_good_prefix(const char* str, D d)
{
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
out << tp;
BOOST_TEST(out.good());
//std::cout << "Expected= " << std::string(str) + boost::chrono::clock_string<Clock, char>::since() << std::endl;
//std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
}
template <typename D>
void test_good_prefix_system_clock(const char* str, D d)
{
typedef boost::chrono::system_clock Clock;
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
out << tp;
BOOST_TEST(out.good());
std::cout << "Expected= " << str << std::endl;
std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST( (out.str() == std::string(str) ));
}
template <typename Clock, typename D>
void test_good_symbol(const char* str, D d)
{
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
#if BOOST_CHRONO_VERSION>=2
out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << tp;
#else
out << boost::chrono::duration_short << tp;
#endif
BOOST_TEST(out.good());
BOOST_TEST( (out.str() == std::string(str) + boost::chrono::clock_string<Clock, char>::since()));
}
#if BOOST_CHRONO_VERSION>=2
template <typename D>
void test_good_symbol_system_clock(const char* str, D d)
{
typedef boost::chrono::system_clock Clock;
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
out << boost::chrono::duration_fmt(boost::chrono::duration_style::symbol) << tp;
BOOST_TEST(out.good());
std::cout << "Expected= " << str << std::endl;
std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST( (out.str() == std::string(str) ));
}
template <typename D>
void test_good_utc_fmt_system_clock(const char* str, const char* fmt, D d)
{
typedef boost::chrono::system_clock Clock;
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
boost::chrono::time_fmt_io_saver<> fmts(out);
boost::chrono::timezone_io_saver tzs(out);
out << time_fmt(boost::chrono::timezone::utc, fmt) << tp;
BOOST_TEST(out.good());
std::cout << "Expected= " << str << std::endl;
std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST_EQ( out.str() , std::string(str) );
}
template <typename D>
void test_good_utc_fmt_system_clock2(const char* str, const char* fmt, D d)
{
typedef boost::chrono::system_clock Clock;
std::ostringstream out;
boost::chrono::time_point<Clock, D> tp(d);
boost::chrono::time_fmt_io_saver<> fmts(out, fmt);
boost::chrono::timezone_io_saver tzs(out, boost::chrono::timezone::utc);
out << tp;
BOOST_TEST(out.good());
std::cout << "Expected= " << str << std::endl;
std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST_EQ( out.str() , std::string(str) );
}
template<typename Clock, typename D>
void test_good(const char* str, D d, boost::chrono::duration_style style)
{
std::ostringstream out;
boost::chrono::time_point<Clock,D> tp(d);
out << boost::chrono::duration_fmt(style) << tp;
BOOST_TEST(out.good());
BOOST_TEST((out.str() == std::string(str)+boost::chrono::clock_string<Clock,char>::since()));
}
template<typename D>
void test_good_system_clock(const char* str, D d, boost::chrono::duration_style style)
{
typedef boost::chrono::system_clock Clock;
std::ostringstream out;
boost::chrono::time_point<Clock,D> tp(d);
out << boost::chrono::duration_fmt(style) << tp;
BOOST_TEST(out.good());
std::cout << "Expected= " << str << std::endl;
std::cout << "Obtained= " << out.str() << std::endl;
BOOST_TEST((out.str() == std::string(str) ));
}
#endif
template <typename Clock>
void check_all()
{
using namespace boost::chrono;
using namespace boost;
#if BOOST_CHRONO_VERSION>=2
test_good<Clock>("2 hours", hours(2), duration_style::prefix);
test_good<Clock>("2 h", hours(2), duration_style::symbol);
#endif
test_good_prefix<Clock> ("2 hours", hours(2));
test_good_prefix<Clock> ("2 minutes", minutes(2));
test_good_prefix<Clock> ("2 seconds", seconds(2));
test_good_prefix<Clock> ("1 second", seconds(1));
test_good_prefix<Clock> ("-1 second", seconds(-1));
test_good_prefix<Clock> ("0 seconds", seconds(0));
test_good_prefix<Clock> ("2 milliseconds", milliseconds(2));
test_good_prefix<Clock> ("2 microseconds", microseconds(2));
test_good_prefix<Clock> ("2 nanoseconds", nanoseconds(2));
test_good_prefix<Clock> ("2 deciseconds", duration<boost::int_least64_t, deci> (2));
test_good_prefix<Clock> ("2 [1/30]seconds", duration<boost::int_least64_t, ratio<1, 30> > (2));
test_good_symbol<Clock> ("2 h", hours(2));
#if BOOST_CHRONO_VERSION>=2
test_good_symbol<Clock>("2 min", minutes(2));
#else
test_good_symbol<Clock> ("2 m", minutes(2));
#endif
test_good_symbol<Clock> ("2 s", seconds(2));
test_good_symbol<Clock> ("2 ms", milliseconds(2));
test_good_symbol<Clock> ("2 ns", nanoseconds(2));
test_good_symbol<Clock> ("2 ds", duration<boost::int_least64_t, deci> (2));
test_good_symbol<Clock> ("2 [1/30]s", duration<boost::int_least64_t, ratio<1, 30> > (2));
}
#if BOOST_CHRONO_VERSION >= 2
void check_all_system_clock()
{
using namespace boost::chrono;
using namespace boost;
test_good_system_clock("1970-01-01 02:00:00.000000000 +0000", hours(2), duration_style::prefix);
test_good_system_clock("1970-01-01 02:00:00.000000000 +0000", hours(2), duration_style::symbol);
test_good_prefix_system_clock("1970-01-01 02:00:00.000000000 +0000", hours(2));
test_good_prefix_system_clock("1970-01-01 00:02:00.000000000 +0000", minutes(2));
test_good_prefix_system_clock("1970-01-01 00:00:02.000000000 +0000", seconds(2));
test_good_prefix_system_clock("1970-01-01 00:00:01.000000000 +0000", seconds(1));
test_good_prefix_system_clock("1969-12-31 23:59:59.000000000 +0000", seconds(-1));
test_good_prefix_system_clock("1970-01-01 00:00:00.000000000 +0000", seconds(0));
test_good_prefix_system_clock("1970-01-01 00:00:00.002000000 +0000", milliseconds(2));
test_good_prefix_system_clock("1970-01-01 00:00:00.000002000 +0000", microseconds(2));
test_good_prefix_system_clock("1970-01-01 00:00:00.000000002 +0000", nanoseconds(2));
test_good_prefix_system_clock("1970-01-01 00:00:00.200000000 +0000", duration<boost::int_least64_t, deci> (2));
test_good_prefix_system_clock("1970-01-01 00:00:00.066666667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (2));
test_good_symbol_system_clock("1970-01-01 02:00:00.000000000 +0000", hours(2));
test_good_symbol_system_clock("1970-01-01 00:02:00.000000000 +0000", minutes(2));
test_good_symbol_system_clock("1970-01-01 00:00:02.000000000 +0000", seconds(2));
test_good_symbol_system_clock("1970-01-01 00:00:00.002000000 +0000", milliseconds(2));
test_good_symbol_system_clock("1970-01-01 00:00:00.000000002 +0000", nanoseconds(2));
test_good_symbol_system_clock("1970-01-01 00:00:00.200000000 +0000", duration<boost::int_least64_t, deci> (2));
test_good_symbol_system_clock("1970-01-01 00:00:00.066666667 +0000", duration<boost::int_least64_t, ratio<1, 30> > (2));
test_good_utc_fmt_system_clock("1970-01-01 02:00:00", "%Y-%m-%d %H:%M:%S", hours(2));
test_good_utc_fmt_system_clock("1970-01-01 02", "%Y-%m-%d %H", hours(2));
#if ! defined(BOOST_CHRONO_WINDOWS_API)
test_good_utc_fmt_system_clock ("1970-01-01 02:00:00", "%Y-%m-%d %T", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02:00", "%Y-%m-%d %R", hours(2));
test_good_utc_fmt_system_clock ("% 1970-01-01 02:00", "%% %Y-%m-%d %R", hours(2));
test_good_utc_fmt_system_clock ("1970-01-01 02:00 Thursday January", "%Y-%m-%d %R %A %B", hours(2));
#endif
test_good_utc_fmt_system_clock2("1970-01-01 02:00:00", "%Y-%m-%d %H:%M:%S", hours(2));
test_good_utc_fmt_system_clock2("1970-01-01 02", "%Y-%m-%d %H", hours(2));
#if ! defined(BOOST_CHRONO_WINDOWS_API)
test_good_utc_fmt_system_clock2 ("1970-01-01 02:00:00", "%Y-%m-%d %T", hours(2));
test_good_utc_fmt_system_clock2 ("1970-01-01 02:00", "%Y-%m-%d %R", hours(2));
test_good_utc_fmt_system_clock2 ("% 1970-01-01 02:00", "%% %Y-%m-%d %R", hours(2));
test_good_utc_fmt_system_clock2 ("1970-01-01 02:00 Thursday January", "%Y-%m-%d %R %A %B", hours(2));
#endif
}
#endif
#if defined BOOST_CHRONO_INTERNAL_GMTIME
#elif BOOST_CHRONO_VERSION == 2
void test_gmtime(std::time_t t)
{
std::cout << "t " << t << std::endl;
std::puts(ctime(&t));
std::tm tm;
std::memset(&tm, 0, sizeof(std::tm));
if (boost::chrono::detail::internal_gmtime(&t, &tm))
{
tm.tm_isdst = -1;
(void)mktime(&tm);
std::tm tm2;
std::memset(&tm2, 0, sizeof(std::tm));
if (gmtime_r(&t, &tm2))
{
tm2.tm_isdst = -1;
(void)mktime(&tm2);
BOOST_TEST_EQ( tm.tm_year , tm2.tm_year );
BOOST_TEST_EQ( tm.tm_mon , tm2.tm_mon );
BOOST_TEST_EQ( tm.tm_mday , tm2.tm_mday );
BOOST_TEST_EQ( tm.tm_hour , tm2.tm_hour);
BOOST_TEST_EQ( tm.tm_min , tm2.tm_min );
BOOST_TEST_EQ( tm.tm_sec , tm2.tm_sec );
BOOST_TEST_EQ( tm.tm_wday , tm2.tm_wday );
BOOST_TEST_EQ( tm.tm_yday , tm2.tm_yday );
BOOST_TEST_EQ( tm.tm_isdst , tm2.tm_isdst );
}
}
}
#endif
int main()
{
#if defined BOOST_CHRONO_INTERNAL_GMTIME
#elif BOOST_CHRONO_VERSION == 2
test_gmtime( 0 );
test_gmtime( -1 );
test_gmtime( +1 );
test_gmtime( 0 - (3600 * 24) );
test_gmtime( -1 - (3600 * 24) );
test_gmtime( +1 - (3600 * 24) );
test_gmtime( 0 + (3600 * 24) );
test_gmtime( -1 + (3600 * 24) );
test_gmtime( +1 + (3600 * 24) );
test_gmtime( 0 + 365*(3600 * 24) );
test_gmtime( 0 + 10LL*365*(3600 * 24) );
test_gmtime( 0 + 15LL*365*(3600 * 24) );
test_gmtime( 0 + 17LL*365*(3600 * 24) );
test_gmtime( 0 + 18LL*365*(3600 * 24) );
test_gmtime( 0 + 19LL*365*(3600 * 24) );
test_gmtime( 0 + 19LL*365*(3600 * 24)+ (3600 * 24));
test_gmtime( 0 + 19LL*365*(3600 * 24)+ 3*(3600 * 24));
test_gmtime( 0 + 19LL*365*(3600 * 24)+ 4*(3600 * 24));
test_gmtime( 0 + 20LL*365*(3600 * 24) );
test_gmtime( 0 + 40LL*365*(3600 * 24) );
#endif
std::cout << "high_resolution_clock=" << std::endl;
check_all<boost::chrono::high_resolution_clock> ();
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
std::cout << "steady_clock=" << std::endl;
check_all<boost::chrono::steady_clock> ();
#endif
std::cout << "system_clock=" << std::endl;
#if BOOST_CHRONO_VERSION >= 2 && defined BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT
check_all_system_clock();
#else
check_all<boost::chrono::system_clock> ();
#endif
#if defined(BOOST_CHRONO_HAS_THREAD_CLOCK)
std::cout << "thread_clock="<< std::endl;
check_all<boost::chrono::thread_clock>();
#endif
#if defined(BOOST_CHRONO_HAS_PROCESS_CLOCKS)
std::cout << "process_real_cpu_clock=" << std::endl;
check_all<boost::chrono::process_real_cpu_clock> ();
#if ! BOOST_OS_WINDOWS || BOOST_PLAT_WINDOWS_DESKTOP
std::cout << "process_user_cpu_clock=" << std::endl;
check_all<boost::chrono::process_user_cpu_clock> ();
std::cout << "process_system_cpu_clock=" << std::endl;
check_all<boost::chrono::process_system_cpu_clock> ();
std::cout << "process_cpu_clock=" << std::endl;
check_all<boost::chrono::process_cpu_clock> ();
#endif
#endif
#if defined BOOST_CHRONO_INTERNAL_GMTIME
#elif BOOST_CHRONO_VERSION == 2
boost::chrono::system_clock::time_point tp = boost::chrono::system_clock::now();
std::cout << tp << std::endl;
time_t t = boost::chrono::system_clock::to_time_t(tp);
test_gmtime( t );
#endif
return boost::report_errors();
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/one_obj.cpp vendored Executable file
View File

@@ -0,0 +1,23 @@
// boost win32_test.cpp -----------------------------------------------------//
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#include <iostream>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
void another();
int main()
{
boost::chrono::steady_clock::time_point t1=boost::chrono::steady_clock::now();
another();
boost::chrono::steady_clock::time_point t2=boost::chrono::steady_clock::now();
std::cout << t2-t1 << std::endl;
return 0;
}

67
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/rep.h vendored Executable file
View File

@@ -0,0 +1,67 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#ifndef REP_H
#define REP_H
#include <boost/config.hpp>
class Rep
{
public:
int data_;
BOOST_CONSTEXPR Rep() : data_() {}
explicit BOOST_CONSTEXPR Rep(int i) : data_(i) {}
BOOST_CONSTEXPR bool operator==(int i) const {return data_ == i;}
BOOST_CONSTEXPR bool operator==(const Rep& r) const {return data_ == r.data_;}
Rep& operator*=(Rep x) {data_ *= x.data_; return *this;}
Rep& operator/=(Rep x) {data_ /= x.data_; return *this;}
};
#if 0
namespace std {
template <>
struct numeric_limits<Rep>
{
static BOOST_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return Rep((std::numeric_limits<int>::max)());
}
};
} // namespace std
namespace boost {
namespace chrono {
template <>
struct duration_values<Rep>
{
static BOOST_CONSTEXPR Rep zero() {return Rep(0);}
static BOOST_CONSTEXPR Rep max BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return Rep((std::numeric_limits<int>::max)());
}
static BOOST_CONSTEXPR Rep min BOOST_PREVENT_MACRO_SUBSTITUTION ()
{
return Rep(detail::numeric_limits<Rep>::lowest());
}
};
} // namespace chrono
} // namespace boost
#endif
#endif // REP_H

226
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/run_timer_test.cpp vendored Executable file
View File

@@ -0,0 +1,226 @@
// boost run_timer_test.cpp -----------------------------------------------------//
// Copyright Beman Dawes 2006, 2008
// Copyright 2009 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#include <boost/chrono/process_times.hpp>
#include <boost/chrono/timer.hpp>
#include <cstdlib> // for atol()
#include <iostream>
#include <sstream>
#include <locale>
#include <ctime>
#include <cmath> // for sqrt(), used to burn time
using boost::chrono::run_timer;
using boost::system::error_code;
#include <boost/detail/lightweight_test.hpp>
//#define BOOST_TEST(expr) if (!(expr)) std::cout << "*****ERROR*****\n"
#define CHECK_REPORT(Timer,String_Stream,R,U,S,Expected_String) \
check_report(Timer, String_Stream, R, U, S, Expected_String, __LINE__)
namespace
{
typedef boost::chrono::nanoseconds ns;
bool check_report( run_timer & tmr, std::stringstream & ss,
run_timer::duration r, run_timer::duration u, run_timer::duration s,
const std::string & expected, int line )
{
tmr.test_report(r,u,s);
bool result(true);
if ( ss.str() != expected )
{
std::cout << "run_timer_test.cpp(" << line << ") : error: actual output \""
<< ss.str() << "\" != expected \"" << expected << "\"\n";
result = false;
}
return result;
}
void run_timer_constructor_overload_test()
{
// exercise each supported combination of constructor arguments
std::ostream & os = std::cout;
const int pl = 9;
boost::system::error_code ec;
run_timer t1;
run_timer t2( os );
run_timer t3( ec );
run_timer t4( os, ec );
run_timer t5( pl );
run_timer t6( os, pl );
run_timer t7( pl, ec );
run_timer t8( os, pl, ec );
run_timer t9( "t9, default places, r %r, c %c, p %p, u %u, s %s\n" );
run_timer t10( os, "t10, default places, r %r, c %c, p %p, u %u, s %s\n" );
run_timer t11( "t11, default places, r %r, c %c, p %p, u %u, s %s\n", ec );
run_timer t12( os, "t12, default places, r %r, c %c, p %p, u %u, s %s\n", ec );
run_timer t13( pl, "t13, explicitly code places, r %r, c %c, p %p, u %u, s %s\n" );
run_timer t14( "t14, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl );
run_timer t15( os, pl, "t15, explicitly code places, r %r, c %c, p %p, u %u, s %s\n" );
run_timer t16( os, "t16, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl );
run_timer t17( pl, "t17, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", ec );
run_timer t18( "t18, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl, ec );
run_timer t19( os, pl, "t19, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", ec );
run_timer t20( os, "t20, explicitly code places, r %r, c %c, p %p, u %u, s %s\n", pl, ec );
std::cout << "Burn some time so run_timers have something to report...";
boost::chrono::timer<boost::chrono::high_resolution_clock> t;
while ( t.elapsed() < boost::chrono::seconds(1) ) {}
std::cout << "\n";
std::cout << run_timer::default_places() << " default places\n";
std::cout << pl << " explicitly coded places\n";
}
// accuracy test
void accuracy_test( int argc, char * argv[] )
{
long timeout_in_secs = 1;
if ( argc > 1 ) timeout_in_secs = std::atol( argv[1] );
std::cout << "accuracy test for " << timeout_in_secs << " second(s)...";
std::clock_t timeout_in_clock_t = std::clock();
timeout_in_clock_t += (timeout_in_secs * CLOCKS_PER_SEC);
boost::chrono::system_timer sys;
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
boost::chrono::steady_timer mono;
#endif
boost::chrono::high_resolution_timer hires;
boost::chrono::process_timer process;
std::clock_t now;
do
{
now = std::clock();
} while ( now < timeout_in_clock_t );
boost::chrono::system_timer::duration sys_dur = sys.elapsed();
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
boost::chrono::steady_timer::duration mono_dur = mono.elapsed();
#endif
boost::chrono::high_resolution_timer::duration hires_dur = hires.elapsed();
boost::chrono::process_times times;
process.elapsed( times );
std::cout << std::endl;
ns timeout_in_nanoseconds( static_cast<long long>(timeout_in_secs) * 1000000000LL );
// Allow 20% leeway. Particularly on Linux, there seems to be a large discrepancy
// between std::clock() and higher resolution clocks.
ns maximum_delta ( static_cast<long long>(timeout_in_nanoseconds.count() * 0.20 ) );
std::cout << timeout_in_nanoseconds.count() << " timeout_in_nanoseconds\n";
std::cout << maximum_delta.count() << " maximum_delta\n";
std::cout << sys_dur.count() << " sys_dur\n";
BOOST_TEST( sys_dur > timeout_in_nanoseconds - maximum_delta
&& sys_dur < timeout_in_nanoseconds + maximum_delta );
#ifdef BOOST_CHRONO_HAS_CLOCK_STEADY
std::cout << mono_dur.count() << " mono_dur\n";
BOOST_TEST( mono_dur > timeout_in_nanoseconds - maximum_delta
&& mono_dur < timeout_in_nanoseconds + maximum_delta );
#endif
std::cout << hires_dur.count() << " hires_dur\n";
BOOST_TEST( hires_dur > timeout_in_nanoseconds - maximum_delta
&& hires_dur < timeout_in_nanoseconds + maximum_delta );
std::cout << times.real.count() << " times.real\n";
BOOST_TEST( times.real > timeout_in_nanoseconds - maximum_delta
&& times.real < timeout_in_nanoseconds + maximum_delta );
}
// report test
void report_test()
{
{
std::stringstream ss;
run_timer t(ss);
BOOST_TEST( CHECK_REPORT(t, ss, ns(0), ns(0), ns(0),
"\nreal 0.000s, cpu 0.000s (0.0%), user 0.000s, system 0.000s\n" ) );
}
{
std::stringstream ss;
run_timer t(ss);
BOOST_TEST( CHECK_REPORT(t, ss, ns(3000000000LL), ns(2000000000LL), ns(1000000000LL),
"\nreal 3.000s, cpu 3.000s (100.0%), user 2.000s, system 1.000s\n" ) );
}
{
std::stringstream ss;
run_timer t( ss, "9 places: r %r, c %c, p %p, u %u, s %s", 9 );
BOOST_TEST( CHECK_REPORT(t, ss, ns(3000000003LL), ns(2000000002LL), ns(1000000001LL),
"9 places: "
"r 3.000000003, c 3.000000003, p 100.0, u 2.000000002, s 1.000000001" ) );
}
}
// process_timer_test
void process_timer_test()
{
std::cout << "process_timer_test..." << std::flush;
boost::chrono::process_timer t;
double res=0; // avoids optimization
for (long i = 0; i < 10000000L; ++i)
{
res+=std::sqrt( static_cast<double>(i) ); // avoids optimization
}
boost::chrono::process_times times;
times.real = times.system = times.user = ns(0);
BOOST_TEST( times.real == ns(0) );
BOOST_TEST( times.user == ns(0) );
BOOST_TEST( times.system == ns(0) );
t.elapsed( times );
std::cout << "\n";
std::cout << times.real.count() << " times.real\n";
std::cout << times.user.count() << " times.user\n";
std::cout << times.system.count() << " times.system\n";
std::cout << (times.user+times.system).count() << " times.user+system\n";
BOOST_TEST( times.real > ns(1) );
BOOST_TEST( times.user+times.system > ns(1) );
std::cout << "complete " << res << std::endl;
}
}
int main( int argc, char * argv[] )
{
std::locale loc( "" ); // test with appropriate locale
std::cout.imbue( loc );
accuracy_test( argc, argv );
run_timer_constructor_overload_test();
process_timer_test();
report_test();
return boost::report_errors();
}

61
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_10631.cpp vendored Executable file
View File

@@ -0,0 +1,61 @@
// Copyright 2015 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#define BOOST_CHRONO_VERION 2
#include <iostream>
#include <boost/chrono/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
// a custom clock
// here based on boost's own system_clock
class MyMillenniumClock
{
public:
typedef boost::chrono::system_clock::rep rep;
typedef boost::chrono::system_clock::period period;
typedef boost::chrono::duration<rep, period> duration;
typedef boost::chrono::time_point<MyMillenniumClock> time_point;
BOOST_STATIC_CONSTEXPR bool is_steady = boost::chrono::system_clock::is_steady;
public:
/// Returns a time_point representing the current value of the clock.
static time_point now() {
return time_point(boost::chrono::system_clock::now().time_since_epoch() - boost::chrono::hours(30*365));
}
};
namespace boost
{
namespace chrono
{
template <class CharT>
struct clock_string<MyMillenniumClock, CharT>
{
static std::basic_string<CharT> name() {
static const CharT a[] = {'M', 'y', 'M', 'i', 'l', 'l', 'e', 'n', 'n', 'i', 'u', 'm', 'C', 'l', 'o', 'c', 'k'};
return std::basic_string<CharT>(a, a + sizeof(a)/sizeof(a[0]));
}
static std::basic_string<CharT> since() {
static const CharT a[] = {' ', 's', 'i', 'n', 'c', 'e', ' ', 'y', 'e', 'a', 'r', ' ', '2', 'k'};
return std::basic_string<CharT>(a, a + sizeof(a)/sizeof(a[0]));
}
};
}
}
template <typename CharT, typename TPUFacet>
std::basic_string<CharT> get_epoch_custom(MyMillenniumClock, TPUFacet&)
{
return boost::chrono::clock_string<MyMillenniumClock,CharT>::since();
}
int main()
{
std::cout << boost::chrono::steady_clock::now() << std::endl;
std::cout << MyMillenniumClock::now() << std::endl;
return 0;
}

19
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_10778.cpp vendored Executable file
View File

@@ -0,0 +1,19 @@
// Copyright 2015 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
//#define BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
#include <boost/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
#include <atomic>
void test()
{
std::atomic<boost::chrono::milliseconds> ms; // error C2338: atomic<T> requires T to be trivially copyable.
}
int main() {
test();
return 1;
}

21
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_11006.cpp vendored Executable file
View File

@@ -0,0 +1,21 @@
// Copyright 2015 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
//#define BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
#define BOOST_CHRONO_VERSION 2
#include <iostream>
#include <boost/chrono/io/time_point_io.hpp>
int main() {
{
boost::chrono::time_fmt_io_saver<> tmp(std::cout);
}
{
boost::chrono::time_fmt_io_saver<> tmp(std::cout, "%Y-%m-%d %H:%M:%S");
}
return 0;
}

27
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_11012.cpp vendored Executable file
View File

@@ -0,0 +1,27 @@
// Copyright 2015 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
//#define BOOST_CHRONO_VERSION 1
#define BOOST_CHRONO_VERSION 2
#include <iostream>
#include <boost/rational.hpp>
#include <boost/chrono/chrono.hpp>
//#define BOOST_CHRONO_DONT_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
#include <boost/chrono/chrono_io.hpp>
int main()
{
{
typedef boost::chrono::duration<float> RationalSeconds;
RationalSeconds d(0.5);
std::cout << d << std::endl;
}
{
typedef boost::chrono::duration<boost::rational<int> > RationalSeconds;
RationalSeconds d;
std::cout << d << std::endl;
}
return 0;
}

11
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_12176.cpp vendored Executable file
View File

@@ -0,0 +1,11 @@
// Copyright 2016 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#include <boost/chrono/chrono.hpp>
int main()
{
return 0;
}

81
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_7868.cpp vendored Executable file
View File

@@ -0,0 +1,81 @@
// Copyright 2013 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#define BOOST_CHRONO_VERSION 2
//#define BOOST_CHRONO_PROVIDES_DATE_IO_FOR_SYSTEM_CLOCK_TIME_POINT 1
#include <sstream>
#include <iostream>
#include <boost/chrono/chrono_io.hpp>
#include <boost/chrono/floor.hpp>
#include <boost/chrono/round.hpp>
#include <boost/chrono/ceil.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <cstdio>
int main()
{
using namespace boost;
using namespace boost::chrono;
boost::chrono::system_clock::time_point atnow= boost::chrono::system_clock::now();
{
std::stringstream strm;
std::stringstream strm2;
// does not change anything: strm<<time_fmt(boost::chrono::timezone::utc);
// does not change anything: strm2<<time_fmt(boost::chrono::timezone::utc);
boost::chrono::system_clock::time_point atnow2;
strm<<atnow<<std::endl;
time_t t = boost::chrono::system_clock::to_time_t(atnow);
std::cout << "A:" << std::endl;
std::puts(ctime(&t));
std::cout << "A:" << std::endl;
std::cout << "A:" << strm.str()<< std::endl;
std::cout << "A:" << atnow.time_since_epoch().count() << std::endl;
strm>>atnow2;
strm2<<atnow2<<std::endl;
std::cout << "B:" << strm2.str()<< std::endl;
std::cout << "B:" << atnow2.time_since_epoch().count()<< std::endl;
BOOST_TEST_EQ(atnow.time_since_epoch().count(), atnow2.time_since_epoch().count());
// 1 sec wrong:
std::cout << "diff:" << boost::chrono::duration_cast<microseconds>(atnow2 - atnow).count() <<std::endl;
BOOST_TEST_EQ(boost::chrono::duration_cast<microseconds>(atnow2 - atnow).count(), 0);
std::stringstream formatted;
formatted << time_fmt(boost::chrono::timezone::utc, "%Y-%m-%d %H:%M:%S");
formatted << "actual:"<< atnow <<std::endl;
formatted << "parsed:"<< atnow2 <<std::endl;
std::cout << formatted.str();
std::stringstream formatted1;
formatted1 << time_fmt(boost::chrono::timezone::utc, "%Y-%m-%d %H:%M:%S");
formatted1 << atnow ;
std::stringstream formatted2;
formatted2 << time_fmt(boost::chrono::timezone::utc, "%Y-%m-%d %H:%M:%S");
formatted2 << atnow2 ;
BOOST_TEST_EQ(formatted1.str(), formatted2.str());
}
{
std::cout << "FORMATTED" << std::endl;
std::stringstream strm;
std::stringstream strm2;
boost::chrono::system_clock::time_point atnow2;
// the final second mark is always parsed as 01
strm<<time_fmt(boost::chrono::timezone::utc, "%Y-%m-%d %H:%M:%S");
strm2<<time_fmt(boost::chrono::timezone::utc, "%Y-%m-%d %H:%M:%S");
strm<<atnow<<std::endl;
std::cout << "actual:" << strm.str()<< std::endl;
strm>>atnow2;
strm2<<atnow2<<std::endl;
// the final second mark is always parsed as 01
std::cout << "parsed:" << strm2.str()<< std::endl;
//BOOST_TEST_EQ(atnow, atnow2); // fails because the pattern doesn't contains nanoseconds
//BOOST_TEST_EQ(atnow.time_since_epoch().count(), atnow2.time_since_epoch().count()); // fails because the pattern doesn't contains nanoseconds
BOOST_TEST_EQ(boost::chrono::duration_cast<seconds>(atnow2 - atnow).count(), 0);
}
return boost::report_errors();
}

27
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/test_9337.cpp vendored Executable file
View File

@@ -0,0 +1,27 @@
//#define BOOST_CHRONO_PROVIDES_DEPRECATED_IO_SINCE_V2_0_0
#include <iostream>
#include <unistd.h>
#include <boost/chrono.hpp>
#include <boost/chrono/chrono_io.hpp>
using namespace std;
using namespace boost::chrono;
template <typename Clock>
void test()
{
typename Clock::time_point start=Clock::now();
sleep(1);
typename Clock::time_point stop=Clock::now();
cout<<stop-start<<endl;
cout << start <<endl;
cout << stop <<endl;
}
int main() {
test<process_cpu_clock>();
test<process_real_cpu_clock>();
test<process_user_cpu_clock>();
test<process_system_cpu_clock>();
return 1;
}

70
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/arithmetic_ext_pass.cpp vendored Executable file
View File

@@ -0,0 +1,70 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#define BOOST_CHRONO_EXTENSIONS
#include <boost/chrono/chrono.hpp>
#include <boost/detail/lightweight_test.hpp>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t += 2;
BOOST_TEST(t.time_since_epoch() == Duration(5));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t++;
BOOST_TEST(t.time_since_epoch() == Duration(4));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
++t;
BOOST_TEST(t.time_since_epoch() == Duration(4));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t -= 2;
BOOST_TEST(t.time_since_epoch() == Duration(1));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t--;
BOOST_TEST(t.time_since_epoch() == Duration(2));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
--t;
BOOST_TEST(t.time_since_epoch() == Duration(2));
}
return boost::report_errors();
}

151
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/arithmetic_pass.cpp vendored Executable file
View File

@@ -0,0 +1,151 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/detail/lightweight_test.hpp>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t += Duration(2);
BOOST_TEST(t.time_since_epoch() == Duration(5));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t -= Duration(2);
BOOST_TEST(t.time_since_epoch() == Duration(1));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5);
BOOST_TEST(t2.time_since_epoch() == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5);
BOOST_CONSTEXPR_ASSERT(t2.time_since_epoch() == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2(Duration2(5));
BOOST_TEST( (t1 - t2) == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration2> t2(Duration2(5));
BOOST_CONSTEXPR_ASSERT( (t1 - t2) == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5);
BOOST_TEST(t2.time_since_epoch() == Duration2(3005));
t2 = Duration2(6) + t1;
BOOST_TEST(t2.time_since_epoch() == Duration2(3006));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5);
BOOST_CONSTEXPR_ASSERT(t2.time_since_epoch() == Duration2(3005));
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration2> t3 = Duration2(6) + t1;
BOOST_CONSTEXPR_ASSERT(t3.time_since_epoch() == Duration2(3006));
}
#ifdef BOOST_CHRONO_EXTENSIONS
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t += 2;
BOOST_TEST(t.time_since_epoch() == Duration(5));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t++;
BOOST_TEST(t.time_since_epoch() == Duration(4));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
++t;
BOOST_TEST(t.time_since_epoch() == Duration(4));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
t -= 2;
BOOST_TEST(t.time_since_epoch() == Duration(1));
}
#if 0
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2 = t1 - Duration2(5);
BOOST_TEST(t2.time_since_epoch() == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2(Duration2(5));
BOOST_TEST((t1 - t2) == Duration2(2995));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
boost::chrono::time_point<Clock, Duration1> t1(Duration1(3));
boost::chrono::time_point<Clock, Duration2> t2 = t1 + Duration2(5);
BOOST_TEST(t2.time_since_epoch() == Duration2(3005));
t2 = Duration2(6) + t1;
BOOST_TEST(t2.time_since_epoch() == Duration2(3006));
}
#endif
#endif
return boost::report_errors();
}

32
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/comparisons/equal_fail.cpp vendored Executable file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// time_points with different clocks should not compare
#include <boost/chrono/chrono.hpp>
#include "../../clock.h"
void test()
{
typedef boost::chrono::system_clock Clock1;
typedef Clock Clock2;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
typedef boost::chrono::time_point<Clock1, Duration1> T1;
typedef boost::chrono::time_point<Clock2, Duration2> T2;
T1 t1(Duration1(3));
T2 t2(Duration2(3000));
t1 == t2;
}

32
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/comparisons/less_fail.cpp vendored Executable file
View File

@@ -0,0 +1,32 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// time_points with different clocks should not compare
#include <boost/chrono/chrono.hpp>
#include "../../clock.h"
void test()
{
typedef boost::chrono::system_clock Clock1;
typedef Clock Clock2;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
typedef boost::chrono::time_point<Clock1, Duration1> T1;
typedef boost::chrono::time_point<Clock2, Duration2> T2;
T1 t1(Duration1(3));
T2 t2(Duration2(3000));
t1 < t2;
}

146
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/comparisons_pass.cpp vendored Executable file
View File

@@ -0,0 +1,146 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/detail/lightweight_test.hpp>
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
typedef boost::chrono::time_point<Clock, Duration1> T1;
typedef boost::chrono::time_point<Clock, Duration2> T2;
{
T1 t1(Duration1(3));
T1 t2(Duration1(3));
BOOST_TEST( (t1 == t2));
BOOST_TEST(! (t1 != t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T1 t2(Duration1(3));
BOOST_CONSTEXPR_ASSERT( (t1 == t2));
BOOST_CONSTEXPR_ASSERT(! (t1 != t2));
}
{
T1 t1(Duration1(3));
T1 t2(Duration1(4));
BOOST_TEST(! (t1 == t2));
BOOST_TEST( (t1 != t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T1 t2(Duration1(4));
BOOST_CONSTEXPR_ASSERT(! (t1 == t2));
BOOST_CONSTEXPR_ASSERT( (t1 != t2));
}
{
T1 t1(Duration1(3));
T2 t2(Duration2(3000));
BOOST_TEST( (t1 == t2));
BOOST_TEST(! (t1 != t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T2 t2(Duration2(3000));
BOOST_CONSTEXPR_ASSERT( (t1 == t2));
BOOST_CONSTEXPR_ASSERT(! (t1 != t2));
}
{
T1 t1(Duration1(3));
T2 t2(Duration2(3001));
BOOST_TEST(! (t1 == t2));
BOOST_TEST( (t1 != t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T2 t2(Duration2(3001));
BOOST_CONSTEXPR_ASSERT(! (t1 == t2));
BOOST_CONSTEXPR_ASSERT( (t1 != t2));
}
{
T1 t1(Duration1(3));
T1 t2(Duration1(3));
BOOST_TEST(! (t1 < t2));
BOOST_TEST(! (t1 > t2));
BOOST_TEST( (t1 <= t2));
BOOST_TEST( (t1 >= t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T1 t2(Duration1(3));
BOOST_CONSTEXPR_ASSERT(! (t1 < t2));
BOOST_CONSTEXPR_ASSERT(! (t1 > t2));
BOOST_CONSTEXPR_ASSERT( (t1 <= t2));
BOOST_CONSTEXPR_ASSERT( (t1 >= t2));
}
{
T1 t1(Duration1(3));
T1 t2(Duration1(4));
BOOST_TEST( (t1 < t2));
BOOST_TEST(! (t1 > t2));
BOOST_TEST( (t1 <= t2));
BOOST_TEST(! (t1 >= t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T1 t2(Duration1(4));
BOOST_CONSTEXPR_ASSERT( (t1 < t2));
BOOST_CONSTEXPR_ASSERT(! (t1 > t2));
BOOST_CONSTEXPR_ASSERT( (t1 <= t2));
BOOST_CONSTEXPR_ASSERT(! (t1 >= t2));
}
{
T1 t1(Duration1(3));
T2 t2(Duration2(3000));
BOOST_TEST(! (t1 < t2));
BOOST_TEST(! (t1 > t2));
BOOST_TEST( (t1 <= t2));
BOOST_TEST( (t1 >= t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T2 t2(Duration2(3000));
BOOST_CONSTEXPR_ASSERT(! (t1 < t2));
BOOST_CONSTEXPR_ASSERT(! (t1 > t2));
BOOST_CONSTEXPR_ASSERT( (t1 <= t2));
BOOST_CONSTEXPR_ASSERT( (t1 >= t2));
}
{
T1 t1(Duration1(3));
T2 t2(Duration2(3001));
BOOST_TEST( (t1 < t2));
BOOST_TEST(! (t1 > t2));
BOOST_TEST( (t1 <= t2));
BOOST_TEST(! (t1 >= t2));
}
{
BOOST_CONSTEXPR T1 t1(Duration1(3));
BOOST_CONSTEXPR T2 t2(Duration2(3001));
BOOST_CONSTEXPR_ASSERT( (t1 < t2));
BOOST_CONSTEXPR_ASSERT(! (t1 > t2));
BOOST_CONSTEXPR_ASSERT( (t1 <= t2));
BOOST_CONSTEXPR_ASSERT(! (t1 >= t2));
}
return boost::report_errors();
}

23
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/cons/implicit_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// test for explicit
#include <boost/chrono/chrono.hpp>
void test()
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t = Duration(3);
}

27
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/cons/non_implicit_convertible_duration_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// Duration2 shall be implicitly convertible to duration.
#include <boost/chrono/chrono.hpp>
void test()
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration1;
typedef boost::chrono::microseconds Duration2;
{
boost::chrono::time_point<Clock, Duration2> t2(Duration2(3));
boost::chrono::time_point<Clock, Duration1> t1 = t2;
}
}

80
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/constructor_pass.cpp vendored Executable file
View File

@@ -0,0 +1,80 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/detail/lightweight_test.hpp>
#include "../rep.h"
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::microseconds Duration1;
typedef boost::chrono::milliseconds Duration2;
boost::chrono::time_point<Clock, Duration2> t2(Duration2(3));
boost::chrono::time_point<Clock, Duration1> t1 = t2;
BOOST_TEST(t1.time_since_epoch() == Duration1(3000));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::microseconds Duration1;
typedef boost::chrono::milliseconds Duration2;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration2> t2(Duration2(3));
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration1> t1 = t2;
BOOST_CONSTEXPR_ASSERT(t1.time_since_epoch() == Duration1(3000));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::duration<Rep, boost::milli> Duration;
boost::chrono::time_point<Clock, Duration> t;
BOOST_TEST(t.time_since_epoch() == Duration::zero());
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::duration<Rep, boost::milli> Duration;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration> t;
BOOST_CONSTEXPR_ASSERT(t.time_since_epoch() == Duration::zero());
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(Duration(3));
BOOST_TEST(t.time_since_epoch() == Duration(3));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration> t(Duration(3));
BOOST_CONSTEXPR_ASSERT(t.time_since_epoch() == Duration(3));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
boost::chrono::time_point<Clock, Duration> t(boost::chrono::seconds(3));
BOOST_TEST(t.time_since_epoch() == Duration(3000));
}
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
BOOST_CONSTEXPR boost::chrono::time_point<Clock, Duration> t(boost::chrono::seconds(3));
BOOST_CONSTEXPR_ASSERT(t.time_since_epoch() == Duration(3000));
}
return boost::report_errors();
}

24
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/default_duration.pass.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
void test()
{
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<boost::chrono::system_clock::duration,
boost::chrono::time_point<boost::chrono::system_clock>::duration>::value), NOTHING, ());
}

24
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/default_duration_pass.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
void test()
{
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<boost::chrono::system_clock::duration,
boost::chrono::time_point<boost::chrono::system_clock>::duration>::value), NOTHING, ());
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/duration.fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// Duration shall be an instance of duration.
#include <boost/chrono/chrono.hpp>
void test()
{
typedef boost::chrono::time_point<boost::chrono::system_clock, int> T;
T t;
}

34
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/min_max_pass.cpp vendored Executable file
View File

@@ -0,0 +1,34 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/detail/lightweight_test.hpp>
#if defined BOOST_NO_CXX11_NUMERIC_LIMITS || defined BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
int main()
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::milliseconds Duration;
typedef boost::chrono::time_point<Clock, Duration> TP;
BOOST_CONSTEXPR_ASSERT((TP::min)() == TP((Duration::min)()));
BOOST_CONSTEXPR_ASSERT((TP::max)() == TP((Duration::max)()));
return boost::report_errors();
}

22
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/not_duration_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// Duration shall be an instance of duration.
#include <boost/chrono/chrono.hpp>
void test()
{
typedef boost::chrono::time_point<boost::chrono::system_clock, int> T;
T t;
}

24
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/time_point_cast_int_fail.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// ToDuration shall be an instantiation of duration.
#include <boost/chrono/chrono.hpp>
void test()
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::time_point<Clock, boost::chrono::milliseconds> FromTimePoint;
typedef boost::chrono::time_point<Clock, boost::chrono::minutes> ToTimePoint;
boost::chrono::time_point_cast<ToTimePoint>(FromTimePoint(boost::chrono::milliseconds(3)));
}

67
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/time_point/time_point_cast_pass.cpp vendored Executable file
View File

@@ -0,0 +1,67 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#include <boost/detail/lightweight_test.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
#ifdef BOOST_NO_CXX11_CONSTEXPR
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_TEST(C)
#else
#include <boost/static_assert.hpp>
#define BOOST_CONSTEXPR_ASSERT(C) BOOST_STATIC_ASSERT(C)
#endif
template <class FromDuration, class ToDuration>
void
test(const FromDuration& df, const ToDuration& d)
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::time_point<Clock, FromDuration> FromTimePoint;
typedef boost::chrono::time_point<Clock, ToDuration> ToTimePoint;
FromTimePoint f(df);
ToTimePoint t(d);
//~ #if defined(BOOST_NO_CXX11_DECLTYPE)
//~ typedef BOOST_TYPEOF_TPL(boost::chrono::time_point_cast<ToDuration>(f)) R;
//~ #else
//~ typedef decltype(boost::chrono::time_point_cast<ToDuration>(f)) R;
//~ #endif
//~ BOOST_CHRONO_STATIC_ASSERT((boost::is_same<R, ToTimePoint>::value), NOTHING, ());
BOOST_TEST(boost::chrono::time_point_cast<ToDuration>(f) == t);
}
int main()
{
test(boost::chrono::milliseconds(7265000), boost::chrono::hours(2));
test(boost::chrono::milliseconds(7265000), boost::chrono::minutes(121));
test(boost::chrono::milliseconds(7265000), boost::chrono::seconds(7265));
test(boost::chrono::milliseconds(7265000), boost::chrono::milliseconds(7265000));
test(boost::chrono::milliseconds(7265000), boost::chrono::microseconds(7265000000LL));
test(boost::chrono::milliseconds(7265000), boost::chrono::nanoseconds(7265000000000LL));
test(boost::chrono::milliseconds(7265000),
boost::chrono::duration<double, boost::ratio<3600> >(7265./3600));
test(boost::chrono::duration<int, boost::ratio<2, 3> >(9),
boost::chrono::duration<int, boost::ratio<3, 5> >(10));
{
typedef boost::chrono::system_clock Clock;
typedef boost::chrono::time_point<Clock, boost::chrono::milliseconds> FromTimePoint;
typedef boost::chrono::time_point<Clock, boost::chrono::hours> ToTimePoint;
BOOST_CONSTEXPR FromTimePoint f(boost::chrono::milliseconds(7265000));
BOOST_CONSTEXPR ToTimePoint tph = boost::chrono::time_point_cast<boost::chrono::hours>(f);
BOOST_CONSTEXPR_ASSERT(tph.time_since_epoch().count() == 2);
}
return boost::report_errors();
}

43
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/traits/common_type_duration_pass.cpp vendored Executable file
View File

@@ -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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits/is_same.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
template <class D1, class D2, class De>
void
test()
{
typedef typename boost::common_type<D1, D2>::type Dc;
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<Dc, De>::value), NOTHING, (D1, D2, Dc, De));
}
void testall()
{
test<boost::chrono::duration<int, boost::ratio<1, 100> >,
boost::chrono::duration<long, boost::ratio<1, 1000> >,
boost::chrono::duration<long, boost::ratio<1, 1000> > >();
test<boost::chrono::duration<long, boost::ratio<1, 100> >,
boost::chrono::duration<int, boost::ratio<1, 1000> >,
boost::chrono::duration<long, boost::ratio<1, 1000> > >();
test<boost::chrono::duration<char, boost::ratio<1, 30> >,
boost::chrono::duration<short, boost::ratio<1, 1000> >,
boost::chrono::duration<int, boost::ratio<1, 3000> > >();
test<boost::chrono::duration<double, boost::ratio<21, 1> >,
boost::chrono::duration<short, boost::ratio<15, 1> >,
boost::chrono::duration<double, boost::ratio<3, 1> > >();
}

47
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/traits/common_type_time_point_pass.cpp vendored Executable file
View File

@@ -0,0 +1,47 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
template <class D1, class D2, class De>
void
test()
{
typedef boost::chrono::system_clock C;
typedef boost::chrono::time_point<C, D1> T1;
typedef boost::chrono::time_point<C, D2> T2;
typedef boost::chrono::time_point<C, De> Te;
typedef typename boost::common_type<T1, T2>::type Tc;
BOOST_CHRONO_STATIC_ASSERT((boost::is_same<Tc, Te>::value), NOTHING, (T1, T2, Tc, Te));
}
void testall()
{
test<boost::chrono::duration<int, boost::ratio<1, 100> >,
boost::chrono::duration<long, boost::ratio<1, 1000> >,
boost::chrono::duration<long, boost::ratio<1, 1000> > >();
test<boost::chrono::duration<long, boost::ratio<1, 100> >,
boost::chrono::duration<int, boost::ratio<1, 1000> >,
boost::chrono::duration<long, boost::ratio<1, 1000> > >();
test<boost::chrono::duration<char, boost::ratio<1, 30> >,
boost::chrono::duration<short, boost::ratio<1, 1000> >,
boost::chrono::duration<int, boost::ratio<1, 3000> > >();
test<boost::chrono::duration<double, boost::ratio<21, 1> >,
boost::chrono::duration<short, boost::ratio<15, 1> >,
boost::chrono::duration<double, boost::ratio<3, 1> > >();
}

41
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/traits/duration_values_pass.cpp vendored Executable file
View File

@@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#include <limits>
#include <boost/detail/lightweight_test.hpp>
#include "../rep.h"
int main()
{
BOOST_TEST((boost::chrono::duration_values<int>::min)() ==
(std::numeric_limits<int>::min)());
BOOST_TEST((boost::chrono::duration_values<double>::min)() ==
-(std::numeric_limits<double>::max)());
BOOST_TEST((boost::chrono::duration_values<Rep>::min)() ==
(std::numeric_limits<Rep>::min)());
BOOST_TEST((boost::chrono::duration_values<int>::max)() ==
(std::numeric_limits<int>::max)());
BOOST_TEST((boost::chrono::duration_values<double>::max)() ==
(std::numeric_limits<double>::max)());
BOOST_TEST((boost::chrono::duration_values<Rep>::max)() ==
(std::numeric_limits<Rep>::max)());
BOOST_TEST(boost::chrono::duration_values<int>::zero() == 0);
BOOST_TEST(boost::chrono::duration_values<Rep>::zero() == 0);
return boost::report_errors();
}

41
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/traits/treat_as_floating_point_pass.cpp vendored Executable file
View File

@@ -0,0 +1,41 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// Adaptation to Boost of the libcxx
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
#include <boost/chrono/chrono.hpp>
#include <boost/type_traits.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
template <class T>
void
test()
{
BOOST_CHRONO_STATIC_ASSERT((boost::is_base_of<boost::is_floating_point<T>,
boost::chrono::treat_as_floating_point<T> >::value), NOTHING, ());
}
struct A {};
void testall()
{
test<int>();
test<unsigned>();
test<char>();
test<bool>();
test<float>();
test<double>();
test<long double>();
test<A>();
}

149
externals/vcpkg/buildtrees/boost-chrono/src/ost-1.79.0-66a76de957.clean/test/win32_test.cpp vendored Executable file
View File

@@ -0,0 +1,149 @@
// boost win32_test.cpp -----------------------------------------------------//
// Copyright 2010 Vicente J. Botet Escriba
// Distributed under the Boost Software License, Version 1.0.
// See http://www.boost.org/LICENSE_1_0.txt
// See http://www.boost.org/libs/chrono for documentation.
#include <boost/chrono/config.hpp>
#include <boost/detail/lightweight_test.hpp>
#if defined(BOOST_CHRONO_WINDOWS_API) || defined(__CYGWIN__)
#include <boost/chrono/detail/static_assert.hpp>
#if !defined(BOOST_NO_CXX11_STATIC_ASSERT)
#define NOTHING ""
#endif
#include <boost/type_traits.hpp>
#include <boost/typeof/typeof.hpp>
#undef BOOST_USE_WINDOWS_H
#include <boost/winapi/basic_types.hpp>
#include <boost/winapi/time.hpp>
#include <windows.h>
void test() {
{
boost::winapi::LARGE_INTEGER_ a;
LARGE_INTEGER b;
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::LARGE_INTEGER_)==sizeof(LARGE_INTEGER)
), NOTHING, (boost::winapi::LARGE_INTEGER_, LARGE_INTEGER));
BOOST_TEST((
sizeof(a.QuadPart)==sizeof(b.QuadPart)
));
BOOST_CHRONO_STATIC_ASSERT((
offsetof(boost::winapi::LARGE_INTEGER_, QuadPart)==offsetof(LARGE_INTEGER, QuadPart)
), NOTHING, (boost::winapi::LARGE_INTEGER_, LARGE_INTEGER));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<
BOOST_TYPEOF(a.QuadPart),
BOOST_TYPEOF(b.QuadPart)
>::value
), NOTHING, (boost::winapi::LARGE_INTEGER_, LARGE_INTEGER));
}
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::BOOL_)==sizeof(BOOL)
), NOTHING, (boost::winapi::BOOL_, BOOL));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::BOOL_,BOOL>::value
), NOTHING, (boost::winapi::BOOL_, BOOL));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::DWORD_)==sizeof(DWORD)
), NOTHING, (boost::winapi::DWORD_, DWORD));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::DWORD_,DWORD>::value
), NOTHING, (boost::winapi::DWORD_, DWORD));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::HANDLE_)==sizeof(HANDLE)
), NOTHING, (boost::winapi::HANDLE_, HANDLE));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::HANDLE_,HANDLE>::value
), NOTHING, (boost::winapi::HANDLE_, HANDLE));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::LONG_)==sizeof(LONG)
), NOTHING, (boost::winapi::LONG_, LONG));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::LONG_,LONG>::value
), NOTHING, (boost::winapi::LONG_, LONG));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::LONGLONG_)==sizeof(LONGLONG)
), NOTHING, (boost::winapi::LONGLONG_, LONGLONG));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::LONGLONG_,LONGLONG>::value
), NOTHING, (boost::winapi::LONGLONG_, LONGLONG));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::ULONG_PTR_)==sizeof(ULONG_PTR)
), NOTHING, (boost::winapi::ULONG_PTR_, ULONG_PTR));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<boost::winapi::ULONG_PTR_,ULONG_PTR>::value
), NOTHING, (boost::winapi::ULONG_PTR_, ULONG_PTR));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::PLARGE_INTEGER_)==sizeof(PLARGE_INTEGER)
), NOTHING, (boost::winapi::PLARGE_INTEGER_, PLARGE_INTEGER));
//~ BOOST_CHRONO_STATIC_ASSERT((
//~ boost::is_same<boost::winapi::PLARGE_INTEGER_,PLARGE_INTEGER>::value
//~ ), NOTHING, (boost::winapi::PLARGE_INTEGER_, PLARGE_INTEGER));
{
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::FILETIME_)==sizeof(FILETIME)
), NOTHING, (boost::winapi::FILETIME_, FILETIME));
BOOST_CHRONO_STATIC_ASSERT((
sizeof(boost::winapi::PFILETIME_)==sizeof(PFILETIME)
), NOTHING, (boost::winapi::PFILETIME_, PFILETIME));
boost::winapi::FILETIME_ a;
FILETIME b;
BOOST_TEST((
sizeof(a.dwLowDateTime)==sizeof(b.dwLowDateTime)
));
BOOST_TEST((
sizeof(a.dwHighDateTime)==sizeof(b.dwHighDateTime)
));
BOOST_CHRONO_STATIC_ASSERT((
offsetof(boost::winapi::FILETIME_, dwLowDateTime)==offsetof(FILETIME, dwLowDateTime)
), NOTHING, (boost::winapi::FILETIME_, FILETIME));
BOOST_CHRONO_STATIC_ASSERT((
offsetof(boost::winapi::FILETIME_, dwHighDateTime)==offsetof(FILETIME, dwHighDateTime)
), NOTHING, (boost::winapi::FILETIME_, FILETIME));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<
BOOST_TYPEOF(a.dwLowDateTime),
BOOST_TYPEOF(b.dwLowDateTime)
>::value
), NOTHING, (boost::winapi::FILETIME_, FILETIME));
BOOST_CHRONO_STATIC_ASSERT((
boost::is_same<
BOOST_TYPEOF(a.dwHighDateTime),
BOOST_TYPEOF(b.dwHighDateTime)
>::value
), NOTHING, (boost::winapi::FILETIME_, FILETIME));
}
// BOOST_CHRONO_STATIC_ASSERT((
// GetLastError==boost::winapi::::GetLastError
// ), NOTHING, ());
}
#else
void test() {
}
#endif
int main( )
{
test();
return boost::report_errors();
}