From 19fcec84d8d7d21e796c7624e521b60d28ee21ed Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 20:45:59 +0200 Subject: Adding upstream version 16.2.11+ds. Signed-off-by: Daniel Baumann --- src/boost/libs/serialization/test/test_tools.hpp | 264 +++++++++++++++++++++++ 1 file changed, 264 insertions(+) create mode 100644 src/boost/libs/serialization/test/test_tools.hpp (limited to 'src/boost/libs/serialization/test/test_tools.hpp') diff --git a/src/boost/libs/serialization/test/test_tools.hpp b/src/boost/libs/serialization/test/test_tools.hpp new file mode 100644 index 000000000..09c0c1c30 --- /dev/null +++ b/src/boost/libs/serialization/test/test_tools.hpp @@ -0,0 +1,264 @@ +#ifndef BOOST_SERIALIZATION_TEST_TOOLS_HPP +#define BOOST_SERIALIZATION_TEST_TOOLS_HPP + +// MS compatible compilers support #pragma once +#if defined(_MSC_VER) +# pragma once +#endif + +#define BOOST_FILESYSTEM_VERSION 3 +#include // unique_path + +/////////1/////////2/////////3/////////4/////////5/////////6/////////7/////////8 +// test_tools.hpp +// +// (C) Copyright 2002 Robert Ramey - http://www.rrsd.com . +// Use, modification and distribution is subject to 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) + +// See http://www.boost.org for updates, documentation, and revision history. + +#include +#ifndef BOOST_NO_EXCEPTION_STD_NAMESPACE + #include +#endif +#include + +#if defined(UNDER_CE) + +// Windows CE does not supply the tmpnam function in its CRT. +// Substitute a primitive implementation here. +namespace boost { +namespace archive { + const char * tmpnam(char * buffer){ + static char ibuffer [512]; + if(NULL == buffer) + buffer = ibuffer; + + static unsigned short index = 0; + std::sprintf(buffer, "\\tmpfile%05X.tmp", index++); + return buffer; + } +} // archive +} // boost + +#elif defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +// win32 has a brain-dead tmpnam implementation. +// which leaves temp files in root directory +// regardless of environmental settings + +#include +#include +#if defined(BOOST_NO_STDC_NAMESPACE) +namespace std{ + using ::remove; + using ::strcpy; + using ::strcat; + using ::tmpnam; +} +#endif // defined(BOOST_NO_STDC_NAMESPACE) + +#include +#include + +//#if defined(__COMO__) + #define chdir _chdir +//#endif // defined win32 + +#if defined(NDEBUG) && defined(__BORLANDC__) + #define STRCPY strcpy +#else + #define STRCPY std::strcpy +#endif + +namespace boost { +namespace archive { + const char * test_filename(const char * dir = NULL, char *fname = NULL){ + static char ibuffer [512]; + ibuffer[0] = '\0'; + if(NULL == dir){ + dir = boost::archive::tmpdir(); + } + STRCPY(ibuffer, dir); + std::strcat(ibuffer, "/"); + if(NULL == fname){ + char old_dir[256]; + _getcwd(old_dir, sizeof(old_dir) - 1); + chdir(dir); + // (C) Copyright 2010 Dean Michael Berris. + // Instead of using std::tmpnam, we use Boost.Filesystem's unique_path + boost::filesystem::path tmp_path = + boost::filesystem::unique_path("%%%%%"); + std::strcat(ibuffer, tmp_path.string().c_str()); + chdir(old_dir); + } + else{ + std::strcat(ibuffer, fname); + } + return ibuffer; + } + const char * tmpnam(char * buffer){ + const char * name = test_filename(NULL, NULL); + if(NULL != buffer){ + STRCPY(buffer, name); + } + return name; + } +} // archive +} // boost + +#else // defined(_WIN32) || defined(__WIN32__) || defined(WIN32) +#if defined(__hpux) +// (C) Copyright 2006 Boris Gubenko. +// HP-UX has a restriction that for multi-thread applications, (i.e. +// the ones compiled -mt) if argument to tmpnam is a NULL pointer, then, +// citing the tmpnam(3S) manpage, "the operation is not performed and a +// NULL pointer is returned". tempnam does not have this restriction, so, +// let's use tempnam instead. + +#define tmpnam(X) tempnam(NULL,X) + +namespace boost { +namespace archive { + using ::tmpnam; +} // archive +} // boost + +#else // defined(__hpux) + +// (C) Copyright 2010 Dean Michael Berris. +// Instead of using the potentially dangrous tempnam function that's part +// of the C standard library, on Unix/Linux we use the more portable and +// "safe" unique_path function provided in the Boost.Filesystem library. + +#include + +namespace boost { +namespace archive { + char const * tmpnam(char * buffer) { + static char name[512] = {0}; + if (name[0] == 0) { + boost::filesystem::path tempdir(tmpdir()); + boost::filesystem::path tempfilename = + boost::filesystem::unique_path("serialization-%%%%"); + boost::filesystem::path temp = tempdir / tempfilename; + std::strcat(name, temp.string().c_str()); + } + if (buffer != 0) std::strcpy(buffer, name); + return name; + } +} // archive +} // boost + +#endif // defined(__hpux) +#endif // defined(_WIN32) || defined(__WIN32__) || defined(WIN32) + +#include + +#define BOOST_CHECK( P ) \ + BOOST_TEST( (P) ) +#define BOOST_REQUIRE( P ) \ + BOOST_TEST( (P) ) +#define BOOST_CHECK_MESSAGE( P, M ) \ + ((P)? (void)0 : ::boost::detail::error_impl( (M) , __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) +#define BOOST_REQUIRE_MESSAGE( P, M ) \ + BOOST_CHECK_MESSAGE( (P), (M) ) +#define BOOST_CHECK_EQUAL( A , B ) \ + BOOST_TEST( (A) == (B) ) + +namespace boost { namespace detail { +inline void msg_impl(char const * msg, char const * file, int line, char const * function) +{ + std::cerr << file << "(" << line << "): " << msg << " in function '" << function << "'" << std::endl; +} +} } // boost::detail + +#define BOOST_WARN_MESSAGE( P, M ) \ + ((P)? (void)0 : ::boost::detail::msg_impl( (M) , __FILE__, __LINE__, BOOST_CURRENT_FUNCTION)) +#define BOOST_MESSAGE( M ) \ + BOOST_WARN_MESSAGE( true , (M) ) + +#define BOOST_CHECKPOINT( M ) \ + BOOST_WARN_MESSAGE( true , (M) ) + +//#define BOOST_TEST_DONT_PRINT_LOG_VALUE( T ) + +#define BOOST_FAIL( M ) BOOST_REQUIRE_MESSAGE( false, (M) ) +#define EXIT_SUCCESS 0 + +int test_main(int argc, char * argv[]); + +#include + +int +main(int argc, char * argv[]){ + boost::serialization::get_singleton_module().lock(); + + int retval = 1; + BOOST_TRY{ + retval = test_main(argc, argv); + } + #ifndef BOOST_NO_EXCEPTION_STD_NAMESPACE + BOOST_CATCH(const std::exception & e){ + BOOST_ERROR(e.what()); + } + #endif + BOOST_CATCH(...){ + BOOST_ERROR("failed with uncaught exception:"); + } + BOOST_CATCH_END + + boost::serialization::get_singleton_module().unlock(); + + int error_count = boost::report_errors(); + if(error_count > 0) + retval = error_count; + return retval; +} + +// the following is to ensure that when one of the libraries changes +// BJAM rebuilds and relinks the test. +/* +#include "text_archive.hpp" +#include "text_warchive.hpp" +#include "binary_archive.hpp" +#include "xml_archive.hpp" +#include "xml_warchive.hpp" + +#include "polymorphic_text_archive.hpp" +#include "polymorphic_text_warchive.hpp" +#include "polymorphic_binary_archive.hpp" +#include "polymorphic_xml_archive.hpp" +#include "polymorphic_xml_warchive.hpp" +*/ + +///////////////////////////////////////////// +// invoke header for a custom archive test. + +///////////////////////////////////////////// +// invoke header for a custom archive test. +#if ! defined(BOOST_ARCHIVE_TEST) +#define BOOST_ARCHIVE_TEST text_archive.hpp +#endif + +#include +#include BOOST_PP_STRINGIZE(BOOST_ARCHIVE_TEST) + +#ifndef TEST_STREAM_FLAGS + #define TEST_STREAM_FLAGS (std::ios_base::openmode)0 +#endif + +#ifndef TEST_ARCHIVE_FLAGS + #define TEST_ARCHIVE_FLAGS 0 +#endif + +#ifndef TEST_DIRECTORY +#define TEST_DIRECTORY +#else +#define __x__ TEST_DIRECTORY +#undef TEST_DIRECTORY +#define TEST_DIRECTORY BOOST_PP_STRINGIZE(__x__) +#endif + +#endif // BOOST_SERIALIZATION_TEST_TOOLS_HPP -- cgit v1.2.3