Initial commit

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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
+
+include(BoostTestJamfile OPTIONAL RESULT_VARIABLE HAVE_BOOST_TEST)
+
+if(HAVE_BOOST_TEST)
+
+boost_test_jamfile(FILE Jamfile.v2 LINK_LIBRARIES Boost::static_assert)
+
+endif()

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/Jamfile.v2

@@ -0,0 +1,21 @@
+# copyright John Maddock 2003
+# Use, modification and distribution are 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)
+
+# bring in the rules for testing
+import testing ;
+
+run static_assert_test.cpp ;
+compile-fail static_assert_test_fail_1.cpp ;
+compile-fail static_assert_test_fail_2.cpp ;
+compile-fail static_assert_test_fail_3.cpp ;
+compile-fail static_assert_test_fail_4.cpp ;
+compile-fail static_assert_test_fail_5.cpp ;
+compile-fail static_assert_test_fail_6.cpp ;
+compile-fail static_assert_test_fail_7.cpp ;
+compile-fail static_assert_test_fail_8.cpp ;
+compile-fail static_assert_test_fail_9.cpp ;
+compile-fail static_assert_test_fail_10.cpp ;
+
+build-project ../example ;

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/cmake_install_test/CMakeLists.txt

@@ -0,0 +1,17 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_install_test LANGUAGES CXX)
+
+find_package(boost_static_assert REQUIRED)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::static_assert)
+
+enable_testing()
+add_test(NAME main COMMAND main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/cmake_install_test/main.cpp

@@ -0,0 +1,7 @@
+#include <boost/static_assert.hpp>
+
+int main()
+{
+    int const x = 5;
+    BOOST_STATIC_ASSERT( x > 4 );
+}

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/cmake_subdir_test/CMakeLists.txt

@@ -0,0 +1,18 @@
+# Copyright 2018, 2019 Peter Dimov
+# 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
+
+cmake_minimum_required(VERSION 3.5...3.16)
+
+project(cmake_subdir_test LANGUAGES CXX)
+
+add_subdirectory(../../../static_assert boostorg/static_assert)
+add_subdirectory(../../../config boostorg/config)
+
+add_executable(main main.cpp)
+target_link_libraries(main Boost::static_assert)
+
+enable_testing()
+add_test(NAME main COMMAND main)
+
+add_custom_target(check COMMAND ${CMAKE_CTEST_COMMAND} --output-on-failure -C $<CONFIG>)

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/cmake_subdir_test/main.cpp

@@ -0,0 +1,7 @@
+#include <boost/static_assert.hpp>
+
+int main()
+{
+    int const x = 5;
+    BOOST_STATIC_ASSERT( x > 4 );
+}

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test.cpp

@@ -0,0 +1,107 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should succeed.
+// some of these tests are rather simplistic (ie useless)
+// in order to ensure that they compile on all platforms.
+//
+
+// Namespace scope
+BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+BOOST_STATIC_ASSERT(sizeof(char) == 1);
+BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg1");
+BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg2");
+
+// Function (block) scope
+void f()
+{
+  BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+  BOOST_STATIC_ASSERT(sizeof(char) == 1);
+  BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg3");
+  BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg4");
+}
+
+struct Bob
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(int) >= sizeof(short));
+    BOOST_STATIC_ASSERT(sizeof(char) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(int) >= sizeof(short), "msg5");
+    BOOST_STATIC_ASSERT_MSG(sizeof(char) == 1, "msg6");
+  public:
+
+  // Member function scope: provides access to member variables
+  int x;
+  char c;
+  int f()
+  {
+#if defined(_MSC_VER) && _MSC_VER < 1300 // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) >= sizeof(short));
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+    BOOST_STATIC_ASSERT_MSG(sizeof(x) >= sizeof(short), "msg7");
+    BOOST_STATIC_ASSERT_MSG(sizeof(c) == 1, "msg8");
+#endif
+    return x;
+  }
+};
+
+
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+   BOOST_STATIC_CONSTANT(int, value = 1);
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) > sizeof(char));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) > sizeof(char), "msg9");
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    BOOST_STATIC_ASSERT_MSG(sizeof(Int) == sizeof(Int2), "msg10");
+    BOOST_STATIC_ASSERT_MSG(sizeof(Char) == sizeof(Char2), "msg11");
+  }
+};
+
+void test_Bill() // BOOST_STATIC_ASSERTs are not triggerred until instantiated
+{
+  Bill<int, char> z;
+  //Bill<int, int> bad; // will not compile
+  int i = 3;
+  char ch = 'a';
+  z.f(i, ch);
+  //z.f(i, i); // should not compile
+}
+
+int main()
+{ 
+   test_Bill();
+   //
+   // Test variadic macro support:
+   //
+#ifndef BOOST_NO_CXX11_VARIADIC_MACROS
+   BOOST_STATIC_ASSERT(Bill<int, char>::value);
+#ifndef BOOST_NO_CXX11_STATIC_ASSERT
+   BOOST_STATIC_ASSERT_MSG(Bill<int, char>::value, "This is a message");
+#endif
+#endif
+   return 0; 
+}
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_1.cpp

@@ -0,0 +1,23 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+// Namespace scope
+BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // will not compile
+
+
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_10.cpp

@@ -0,0 +1,18 @@
+//~ Copyright 2005 Redshift Software, Inc.
+//~ 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)
+
+#include <boost/static_assert.hpp>
+
+template <int N>
+int foo()
+{
+    BOOST_STATIC_ASSERT( N < 2 );
+    
+    return N;
+}
+
+int main()
+{
+    return foo<5>();
+}

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_2.cpp

@@ -0,0 +1,25 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+// Function (block) scope
+void f()
+{
+  BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // should not compile
+}
+
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_3.cpp

@@ -0,0 +1,39 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// this tests should fail:
+//
+typedef char a1[2];
+typedef char a2[3];
+
+struct Bob
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(a1) == sizeof(a2)); // will not compile
+  public:
+
+  // Member function scope: provides access to member variables
+  int x;
+  char c;
+  int f()
+  {
+#ifndef _MSC_VER // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) == 4);
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+#endif
+    return x;
+  }
+};
+
+
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_4.cpp

@@ -0,0 +1,38 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/config.hpp>
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+
+struct Bob
+{
+  public:
+
+  // Member function scope: provides access to member variables
+  char x[4];
+  char c;
+  int f()
+  {
+#if !defined(BOOST_MSVC) || BOOST_MSVC > 1200 // broken sizeof in VC6
+    BOOST_STATIC_ASSERT(sizeof(x) == 4);
+    BOOST_STATIC_ASSERT(sizeof(c) == 1);
+    BOOST_STATIC_ASSERT((sizeof(x) == sizeof(c))); // should not compile
+#endif
+    return x;
+  }
+};
+
+
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_5.cpp

@@ -0,0 +1,39 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) == 4);
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    //BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  }
+};
+
+Bill<int, char> b;
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_6.cpp

@@ -0,0 +1,46 @@
+//  (C) Copyright Steve Cleary & John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <boost/static_assert.hpp>
+
+//
+// all these tests should fail:
+//
+
+// Template class scope
+template <class Int, class Char>
+struct Bill
+{
+  private:  // can be in private, to avoid namespace pollution
+    BOOST_STATIC_ASSERT(sizeof(Int) == 4);
+    //BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  public:
+
+  // Template member function scope: provides access to member variables
+  Int x;
+  Char c;
+  template <class Int2, class Char2>
+  void f(Int2 , Char2 )
+  {
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Int2));
+    BOOST_STATIC_ASSERT(sizeof(Char) == sizeof(Char2));
+    BOOST_STATIC_ASSERT(sizeof(Int) == sizeof(Char)); // should not compile when instantiated
+  }
+};
+
+void foo()
+{
+   int i = 0;
+   char c = 0;
+   Bill<int, char> b;
+   // this should fail:
+   b.f(i, c);
+}
+
+
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_7.cpp

@@ -0,0 +1,31 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <climits>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+
+template <class UnsignedInt>
+class myclass
+{
+private:
+   BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
+   BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
+                        && std::numeric_limits<UnsignedInt>::is_integer
+                        && !std::numeric_limits<UnsignedInt>::is_signed);
+public:
+   /* details here */
+};
+
+myclass<int>           m2; // this should fail
+myclass<unsigned char> m3; // and so should this
+
+int main()
+{
+   return 0;
+}
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_8.cpp

@@ -0,0 +1,44 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <iterator>
+#include <list>
+#include <deque>
+#include <boost/static_assert.hpp>
+#include <boost/type_traits.hpp>
+
+template <class RandomAccessIterator >
+RandomAccessIterator foo(RandomAccessIterator from, RandomAccessIterator)
+{
+   // this template can only be used with
+   // random access iterators...
+   typedef typename std::iterator_traits< RandomAccessIterator >::iterator_category cat;
+   BOOST_STATIC_ASSERT((boost::is_convertible<cat*, std::random_access_iterator_tag*>::value));
+   //
+   // detail goes here...
+   return from;
+}
+
+// ensure that delayed instantiation compilers like Comeau see the failure early
+// enough for "compile-fail" testing with the Boost.Build testing framework. (Greg Comeau)
+template
+std::list<int>::iterator
+   foo(std::list<int>::iterator, std::list<int>::iterator);
+
+int main()
+{
+   std::deque<int> d;
+   std::list<int> l;
+   foo(d.begin(), d.end()); // OK
+   foo(l.begin(), l.end()); // error
+   return 0;
+}
+
+
+ 
+
+

externals/vcpkg/buildtrees/boost-static-assert/src/ost-1.79.0-61c189c6f4.clean/test/static_assert_test_fail_9.cpp

@@ -0,0 +1,32 @@
+//  (C) Copyright John Maddock 2000.
+//  Use, modification and distribution are 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 most recent version including documentation.
+
+#include <climits>
+#include <boost/limits.hpp>
+#include <boost/static_assert.hpp>
+
+template <class UnsignedInt>
+class myclass
+{
+private:
+   BOOST_STATIC_ASSERT(sizeof(UnsignedInt) * CHAR_BIT >= 16);
+   BOOST_STATIC_ASSERT(std::numeric_limits<UnsignedInt>::is_specialized
+                        && std::numeric_limits<UnsignedInt>::is_integer
+                        && !std::numeric_limits<UnsignedInt>::is_signed);
+public:
+   /* details here */
+};
+
+myclass<unsigned>      m1; // this should be OK
+//myclass<int>           m2; // this should fail
+myclass<unsigned char> m3; // and so should this
+
+int main()
+{
+   return 0;
+}
+