early-access version 3088

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/Jamfile.v2

@@ -0,0 +1,94 @@
+#  Boost algorithm library test suite Jamfile  ----------------------------
+#
+#  Copyright Marshall Clow 2010-2012. 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.
+
+import testing ;
+
+alias unit_test_framework
+    : # sources
+        /boost//unit_test_framework
+    ;
+
+
+{
+  test-suite algorithm
+# Search tests
+   : [ run empty_search_test.cpp unit_test_framework      : : : : empty_search_test ]
+     [ run search_test1.cpp unit_test_framework           : : : : search_test1 ]
+     [ run search_test2.cpp unit_test_framework           : : : : search_test2 ]
+     [ run search_test3.cpp unit_test_framework           : : : : search_test3 ]
+     [ run search_test4.cpp unit_test_framework           : : : : search_test4 ]
+     [ compile-fail search_fail1.cpp  : : : : ]
+     [ compile-fail search_fail2.cpp  : : : : ]
+     [ compile-fail search_fail3.cpp  : : : : ]
+
+# Misc tests
+     [ run clamp_test.cpp unit_test_framework         : : : : clamp_test ]
+     [ run power_test.cpp unit_test_framework         : : : : power_test ]
+     [ compile-fail power_fail1.cpp  : : : : ]
+
+# Cxx11 tests
+     [ run all_of_test.cpp unit_test_framework         : : : : all_of_test ]
+     [ run any_of_test.cpp unit_test_framework         : : : : any_of_test ]
+     [ run none_of_test.cpp unit_test_framework        : : : : none_of_test ]
+     [ run one_of_test.cpp unit_test_framework         : : : : one_of_test ]
+
+     [ run ordered_test.cpp unit_test_framework        : : : : ordered_test ]
+     [ run find_if_not_test1.cpp unit_test_framework   : : : : find_if_not_test1 ]
+     [ run copy_if_test1.cpp unit_test_framework        : : : : copy_if_test1 ]
+     [ run copy_n_test1.cpp unit_test_framework       : : : : copy_n_test1 ]
+     [ run iota_test1.cpp unit_test_framework          : : : : iota_test1 ]
+
+     [ run is_permutation_test1.cpp unit_test_framework         : : : : is_permutation_test1 ]
+     [ run partition_point_test1.cpp unit_test_framework        : : : : partition_point_test1 ]
+     [ run is_partitioned_test1.cpp unit_test_framework         : : : : is_partitioned_test1 ]
+     [ run partition_copy_test1.cpp unit_test_framework         : : : : partition_copy_test1 ]
+
+# Cxx14 tests
+     [ run equal_test.cpp unit_test_framework         : : : : equal_test ]
+     [ run mismatch_test.cpp unit_test_framework      : : : : mismatch_test ]
+
+# Cxx17 tests
+     [ run for_each_n_test.cpp unit_test_framework         : : : : for_each_n_test ]
+     [ run reduce_test.cpp unit_test_framework             : : : : reduce_test ]
+     [ run transform_reduce_test.cpp unit_test_framework   : : : : transform_reduce_test ]
+     [ run inclusive_scan_test.cpp unit_test_framework             : : : : inclusive_scan_test ]
+     [ run exclusive_scan_test.cpp unit_test_framework             : : : : exclusive_scan_test ]
+     [ run transform_inclusive_scan_test.cpp unit_test_framework   : : : : transform_inclusive_scan_test ]
+     [ run transform_exclusive_scan_test.cpp unit_test_framework   : : : : transform_exclusive_scan_test ]
+# Maybe GCD and LCM as well
+
+# Hex tests
+     [ run hex_test1.cpp unit_test_framework         : : : : hex_test1 ]
+     [ run hex_test2.cpp unit_test_framework         : : : : hex_test2 ]
+     [ run hex_test3.cpp unit_test_framework         : : : : hex_test3 ]
+     [ run hex_test4.cpp unit_test_framework         : : : : hex_test4 ]
+     [ compile-fail hex_fail1.cpp ]
+
+# Gather tests
+     [ run gather_test1.cpp unit_test_framework        : : : : gather_test1 ]
+     [ compile-fail gather_fail1.cpp ]
+
+# SortSubrange tests
+     [ run sort_subrange_test.cpp unit_test_framework       : : : : sort_subrange_test ]
+     [ run partition_subrange_test.cpp unit_test_framework  : : : : partition_subrange_test ]
+
+# Is_palindrome tests
+     [ run is_palindrome_test.cpp unit_test_framework    : : : : is_palindrome_test ]
+
+# Is_partitioned_until tests
+     [ run is_partitioned_until_test.cpp unit_test_framework    : : : : is_partitioned_until_test ]
+   
+# Apply_permutation tests
+     [ run apply_permutation_test.cpp unit_test_framework    : : : : apply_permutation_test ]
+# Find tests
+     [ run find_not_test.cpp unit_test_framework   : : : : find_not_test ]
+     [ run find_backward_test.cpp unit_test_framework   : : : : find_backward_test ]
+   ;
+}
+

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/all_of_test.cpp

@@ -0,0 +1,94 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/all_of.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <functional>
+#include <vector>
+#include <list>
+
+template<typename T>
+struct is_ {
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
+private:
+    is_ (); // need a value
+
+    T val_;
+    };
+
+namespace ba = boost::algorithm;
+
+void test_all ()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 1, 1, 18, 10 };
+    std::vector<int> vi(some_numbers, some_numbers + 5);
+    std::list<int>   li(vi.begin(), vi.end ());
+    
+    int some_letters[] = { 'a', 'q', 'n', 'y', 'n' };
+    std::vector<char> vc(some_letters, some_letters + 5);
+    
+    
+    BOOST_CHECK (!ba::all_of_equal ( vi,                                  1 ));
+    BOOST_CHECK (!ba::all_of       ( vi,                       is_<int> ( 1 )));
+    BOOST_CHECK (!ba::all_of_equal ( vi.begin(),     vi.end(),            1 ));
+    BOOST_CHECK (!ba::all_of       ( vi.begin(),     vi.end(), is_<int> ( 1 )));
+    
+    BOOST_CHECK (!ba::all_of_equal ( vi,                                  0 ));
+    BOOST_CHECK (!ba::all_of       ( vi,                       is_<int> ( 0 )));
+    BOOST_CHECK (!ba::all_of_equal ( vi.begin(),     vi.end(),            0 ));
+    BOOST_CHECK (!ba::all_of       ( vi.begin(),     vi.end(), is_<int> ( 0 )));
+
+    BOOST_CHECK ( ba::all_of_equal ( vi.end(),       vi.end(),            0 ));
+    BOOST_CHECK ( ba::all_of       ( vi.end(),       vi.end(), is_<int> ( 0 )));
+
+    BOOST_CHECK ( ba::all_of_equal ( vi.begin(), vi.begin () + 3,            1 ));
+    BOOST_CHECK ( ba::all_of       ( vi.begin(), vi.begin () + 3, is_<int> ( 1 )));
+    
+    BOOST_CHECK ( ba::all_of_equal ( vc.begin() + 1, vc.begin() + 2,             'q' ));
+    BOOST_CHECK ( ba::all_of       ( vc.begin() + 1, vc.begin() + 2, is_<char> ( 'q' )));
+
+    BOOST_CHECK (!ba::all_of_equal ( vc,             '!' ));
+    BOOST_CHECK (!ba::all_of       ( vc, is_<char> ( '!' )));
+
+    BOOST_CHECK ( ba::all_of_equal ( vi.begin(), vi.begin(),   1 ));
+    BOOST_CHECK ( ba::all_of_equal ( vc.begin(), vc.begin(), 'a' ));
+    BOOST_CHECK ( ba::all_of       ( vi.begin(), vi.begin(), is_<int>  (   1 )));
+    BOOST_CHECK ( ba::all_of       ( vc.begin(), vc.begin(), is_<char> ( 'a' )));
+
+    BOOST_CHECK (!ba::all_of_equal ( li,                                  1 ));
+    BOOST_CHECK (!ba::all_of       ( li,                       is_<int> ( 1 )));
+    BOOST_CHECK (!ba::all_of_equal ( li.begin(),     li.end(),            1 ));
+    BOOST_CHECK (!ba::all_of       ( li.begin(),     li.end(), is_<int> ( 1 )));
+    
+    std::list<int>::iterator l_iter = li.begin ();
+    l_iter++; l_iter++; l_iter++;
+    BOOST_CHECK ( ba::all_of_equal ( li.begin(), l_iter,            1 ));
+    BOOST_CHECK ( ba::all_of       ( li.begin(), l_iter, is_<int> ( 1 )));
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+        !ba::all_of_equal ( some_numbers, 1 )                               &&
+        !ba::all_of       ( some_numbers, is_<int> ( 1 ))                   &&
+         ba::all_of_equal ( some_numbers, some_numbers + 3,            1 )  &&
+         ba::all_of       ( some_numbers, some_numbers + 3, is_<int> ( 1 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_all ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/any_of_test.cpp

@@ -0,0 +1,114 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/any_of.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <functional>
+#include <vector>
+#include <list>
+
+template<typename T>
+struct is_ {
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
+private:
+    is_ (); // need a value
+
+    T val_;
+    };
+
+namespace ba = boost::algorithm;
+
+void test_any ()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 5, 0, 18, 10 };
+    std::vector<int> vi(some_numbers, some_numbers + 5);
+    std::list<int>   li(vi.begin(), vi.end ());
+
+    int some_letters[] = { 'a', 'q', 'n', 'y', 'n' };
+    std::vector<char> vc(some_letters, some_letters + 5);
+    
+    BOOST_CHECK ( ba::any_of_equal ( vi,                                   1 ));
+    BOOST_CHECK ( ba::any_of       ( vi,                       is_<int> (  1 )));
+    BOOST_CHECK ( ba::any_of_equal ( vi.begin(),     vi.end(),             1 ));
+    BOOST_CHECK ( ba::any_of       ( vi.begin(),     vi.end(), is_<int> (  1 )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vi,                                   9 ));
+    BOOST_CHECK (!ba::any_of       ( vi,                       is_<int> (  9 )));
+    BOOST_CHECK (!ba::any_of_equal ( vi.begin(),     vi.end(),             9 ));
+    BOOST_CHECK (!ba::any_of       ( vi.begin(),     vi.end(), is_<int> (  9 )));
+
+    BOOST_CHECK ( ba::any_of_equal ( vi,                                  10 ));
+    BOOST_CHECK ( ba::any_of       ( vi,                       is_<int> ( 10 )));
+    BOOST_CHECK (!ba::any_of_equal ( vi,                                   4 ));
+    BOOST_CHECK (!ba::any_of       ( vi,                       is_<int> (  4 )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vi.end(),       vi.end(),            0 ));
+    BOOST_CHECK (!ba::any_of       ( vi.end(),       vi.end(), is_<int> ( 0 )));
+
+//   5 is not in { 0, 18, 10 }, but 10 is
+    BOOST_CHECK ( ba::any_of_equal ( vi.begin() + 2, vi.end(),            10 ));
+    BOOST_CHECK ( ba::any_of       ( vi.begin() + 2, vi.end(), is_<int> ( 10 )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vi.begin() + 2, vi.end(),             5 ));
+    BOOST_CHECK (!ba::any_of       ( vi.begin() + 2, vi.end(), is_<int> (  5 )));
+
+//  18 is not in { 1, 5, 0 }, but 5 is
+    BOOST_CHECK ( ba::any_of_equal ( vi.begin(), vi.begin() + 3,             5 ));
+    BOOST_CHECK ( ba::any_of       ( vi.begin(), vi.begin() + 3, is_<int> (  5 )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vi.begin(), vi.begin() + 3,            18 ));
+    BOOST_CHECK (!ba::any_of       ( vi.begin(), vi.begin() + 3, is_<int> ( 18 )));
+
+    BOOST_CHECK ( ba::any_of_equal ( vc,             'q' ));
+    BOOST_CHECK ( ba::any_of       ( vc, is_<char> ( 'q' )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vc,             '!' ));
+    BOOST_CHECK (!ba::any_of       ( vc, is_<char> ( '!' )));
+
+    BOOST_CHECK ( ba::any_of_equal ( vc,             'n' ));
+    BOOST_CHECK ( ba::any_of       ( vc, is_<char> ( 'n' )));
+
+    BOOST_CHECK (!ba::any_of_equal ( vi.begin(), vi.begin(),   1 ));
+    BOOST_CHECK (!ba::any_of_equal ( vc.begin(), vc.begin(), 'a' ));
+    BOOST_CHECK (!ba::any_of       ( vi.begin(), vi.begin(), is_<int>  (   1 )));
+    BOOST_CHECK (!ba::any_of       ( vc.begin(), vc.begin(), is_<char> ( 'a' )));
+
+    BOOST_CHECK ( ba::any_of_equal ( li,                                   1 ));
+    BOOST_CHECK ( ba::any_of       ( li,                       is_<int> (  1 )));
+    BOOST_CHECK ( ba::any_of_equal ( li.begin(),     li.end(),             1 ));
+    BOOST_CHECK ( ba::any_of       ( li.begin(),     li.end(), is_<int> (  1 )));
+    
+    std::list<int>::iterator l_iter = li.begin ();
+    l_iter++; l_iter++; l_iter++;
+    BOOST_CHECK ( ba::any_of_equal ( li.begin(), l_iter,             5 ));
+    BOOST_CHECK ( ba::any_of       ( li.begin(), l_iter, is_<int> (  5 )));
+    BOOST_CHECK (!ba::any_of_equal ( li.begin(), l_iter,            18 ));
+    BOOST_CHECK (!ba::any_of       ( li.begin(), l_iter, is_<int> ( 18 )));
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+         ba::any_of_equal ( some_numbers, 1 )                                 &&
+         ba::any_of       ( some_numbers, is_<int> ( 1 ))                     &&
+        !ba::any_of_equal ( some_numbers, some_numbers + 3,            777 )  &&
+        !ba::any_of       ( some_numbers, some_numbers + 3, is_<int> ( 777 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_any ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/apply_permutation_test.cpp

@@ -0,0 +1,162 @@
+/*
+  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2017
+
+  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)
+
+  See http://www.boost.org/ for latest version.
+*/
+
+#include <vector>
+
+#include <boost/algorithm/apply_permutation.hpp>
+
+#define BOOST_TEST_MAIN
+
+#include <boost/test/included/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+
+BOOST_AUTO_TEST_CASE(test_apply_permutation)
+{
+    //Empty
+    {
+        std::vector<int> vec, order, result;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //1 element
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1);
+        order.push_back(0);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(0); order.push_back(1);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(1); order.push_back(0);
+        result.push_back(2); result.push_back(1);
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(4); order.push_back(3); order.push_back(2); order.push_back(1); order.push_back(0);
+        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
+        
+        ba::apply_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Just test range interface
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_permutation(vec, order);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+}
+
+BOOST_AUTO_TEST_CASE(test_apply_reverse_permutation)
+{
+    //Empty
+    {
+        std::vector<int> vec, order, result;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //1 element
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1);
+        order.push_back(0);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(0); order.push_back(1);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //2 elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2);
+        order.push_back(1); order.push_back(0);
+        result.push_back(2); result.push_back(1);
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, no changes
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Multiple elements, changed
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(4); order.push_back(3); order.push_back(2); order.push_back(1); order.push_back(0);
+        result.push_back(5); result.push_back(4); result.push_back(3); result.push_back(2); result.push_back(1);
+        
+        ba::apply_reverse_permutation(vec.begin(), vec.end(), order.begin(), order.end());
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+    //Just test range interface
+    {
+        std::vector<int> vec, order, result;
+        vec.push_back(1); vec.push_back(2); vec.push_back(3); vec.push_back(4); vec.push_back(5);
+        order.push_back(0); order.push_back(1); order.push_back(2); order.push_back(3); order.push_back(4);
+        result = vec;
+        
+        ba::apply_reverse_permutation(vec, order);
+        BOOST_CHECK_EQUAL_COLLECTIONS(vec.begin(), vec.end(), result.begin(), result.end());
+    }
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/clamp_test.cpp

@@ -0,0 +1,328 @@
+//  (C) Copyright Jesse Williamson 2009
+//  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)
+
+#include <iostream>
+#include <vector>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/clamp.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+BOOST_CONSTEXPR bool intGreater    ( int lhs, int rhs )       { return lhs > rhs; }
+BOOST_CONSTEXPR bool doubleGreater ( double lhs, double rhs ) { return lhs > rhs; }
+
+class custom {
+public:
+    custom ( int x )             : v(x)     {}
+    custom ( const custom &rhs ) : v(rhs.v) {}
+    ~custom () {}
+    custom & operator = ( const custom &rhs ) { v = rhs.v; return *this; }
+    
+    bool operator <  ( const custom &rhs ) const { return v < rhs.v; }
+    bool operator == ( const custom &rhs ) const { return v == rhs.v; }     // need this for the test
+    
+    std::ostream & print ( std::ostream &os ) const { return os << v; }
+    
+    int v;
+    };
+
+std::ostream & operator << ( std::ostream & os, const custom &x ) { return x.print ( os ); }
+
+bool customLess ( const custom &lhs, const custom &rhs ) { return lhs.v < rhs.v; }
+
+void test_ints()
+{
+
+//  Inside the range, equal to the endpoints, and outside the endpoints.
+    BOOST_CHECK_EQUAL (  3, ba::clamp (  3, 1, 10 ));
+    BOOST_CHECK_EQUAL (  1, ba::clamp (  1, 1, 10 ));
+    BOOST_CHECK_EQUAL (  1, ba::clamp (  0, 1, 10 ));
+    BOOST_CHECK_EQUAL ( 10, ba::clamp ( 10, 1, 10 ));
+    BOOST_CHECK_EQUAL ( 10, ba::clamp ( 11, 1, 10 ));
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+        ba::clamp (  3, 1, 10 ) == 3
+    );
+    BOOST_CHECK( constexpr_res );
+    
+    BOOST_CHECK_EQUAL (  3, ba::clamp (  3, 10, 1, intGreater ));
+    BOOST_CHECK_EQUAL (  1, ba::clamp (  1, 10, 1, intGreater ));
+    BOOST_CHECK_EQUAL (  1, ba::clamp (  0, 10, 1, intGreater ));
+    BOOST_CHECK_EQUAL ( 10, ba::clamp ( 10, 10, 1, intGreater ));
+    BOOST_CHECK_EQUAL ( 10, ba::clamp ( 11, 10, 1, intGreater ));
+
+//  Negative numbers
+    BOOST_CHECK_EQUAL (  -3, ba::clamp (  -3, -10, -1 ));
+    BOOST_CHECK_EQUAL (  -1, ba::clamp (  -1, -10, -1 ));
+    BOOST_CHECK_EQUAL (  -1, ba::clamp (   0, -10, -1 ));
+    BOOST_CHECK_EQUAL ( -10, ba::clamp ( -10, -10, -1 ));
+    BOOST_CHECK_EQUAL ( -10, ba::clamp ( -11, -10, -1 ));
+
+//  Mixed positive and negative numbers
+    BOOST_CHECK_EQUAL (   5, ba::clamp (   5, -10, 10 ));
+    BOOST_CHECK_EQUAL ( -10, ba::clamp ( -10, -10, 10 ));
+    BOOST_CHECK_EQUAL ( -10, ba::clamp ( -15, -10, 10 ));
+    BOOST_CHECK_EQUAL (  10, ba::clamp (  10, -10, 10 ));
+    BOOST_CHECK_EQUAL (  10, ba::clamp (  15, -10, 10 ));
+
+//  Unsigned 
+    BOOST_CHECK_EQUAL (  5U, ba::clamp (  5U, 1U, 10U ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  1U, 1U, 10U ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  0U, 1U, 10U ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 10U, 1U, 10U ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 15U, 1U, 10U ));
+    
+//  Mixed (1)
+    BOOST_CHECK_EQUAL (  5U, ba::clamp (  5U, 1,  10 ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  1U, 1,  10 ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  0U, 1,  10 ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 10U, 1,  10 ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 15U, 1,  10 ));
+    
+//  Mixed (3)
+    BOOST_CHECK_EQUAL (  5U, ba::clamp (  5U, 1,  10. ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  1U, 1,  10. ));
+    BOOST_CHECK_EQUAL (  1U, ba::clamp (  0U, 1,  10. ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 10U, 1,  10. ));
+    BOOST_CHECK_EQUAL ( 10U, ba::clamp ( 15U, 1,  10. ));
+    
+    short foo = 50;
+    BOOST_CHECK_EQUAL ( 56,     ba::clamp ( foo, 56.9, 129 ));
+    BOOST_CHECK_EQUAL ( 24910,  ba::clamp ( foo, 12345678, 123456999 ));
+    }
+
+
+void test_floats()
+{
+
+//  Inside the range, equal to the endpoints, and outside the endpoints.
+    BOOST_CHECK_EQUAL (  3.0, ba::clamp (  3.0, 1.0, 10.0 ));
+    BOOST_CHECK_EQUAL (  1.0, ba::clamp (  1.0, 1.0, 10.0 ));
+    BOOST_CHECK_EQUAL (  1.0, ba::clamp (  0.0, 1.0, 10.0 ));
+    BOOST_CHECK_EQUAL ( 10.0, ba::clamp ( 10.0, 1.0, 10.0 ));
+    BOOST_CHECK_EQUAL ( 10.0, ba::clamp ( 11.0, 1.0, 10.0 ));
+    
+    BOOST_CHECK_EQUAL (  3.0, ba::clamp (  3.0, 10.0, 1.0, doubleGreater ));
+    BOOST_CHECK_EQUAL (  1.0, ba::clamp (  1.0, 10.0, 1.0, doubleGreater ));
+    BOOST_CHECK_EQUAL (  1.0, ba::clamp (  0.0, 10.0, 1.0, doubleGreater ));
+    BOOST_CHECK_EQUAL ( 10.0, ba::clamp ( 10.0, 10.0, 1.0, doubleGreater ));
+    BOOST_CHECK_EQUAL ( 10.0, ba::clamp ( 11.0, 10.0, 1.0, doubleGreater ));
+
+//  Negative numbers
+    BOOST_CHECK_EQUAL (  -3.f, ba::clamp (  -3.f, -10.f, -1.f ));
+    BOOST_CHECK_EQUAL (  -1.f, ba::clamp (  -1.f, -10.f, -1.f ));
+    BOOST_CHECK_EQUAL (  -1.f, ba::clamp (   0.f, -10.f, -1.f ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -10.f, -10.f, -1.f ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -11.f, -10.f, -1.f ));
+
+//  Mixed positive and negative numbers
+    BOOST_CHECK_EQUAL (   5.f, ba::clamp (   5.f, -10.f, 10.f ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -10.f, -10.f, 10.f ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -15.f, -10.f, 10.f ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  10.f, -10.f, 10.f ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  15.f, -10.f, 10.f ));
+
+//  Mixed (1)
+    BOOST_CHECK_EQUAL (   5.f, ba::clamp (   5.f, -10., 10. ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -10.f, -10., 10. ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -15.f, -10., 10. ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  10.f, -10., 10. ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  15.f, -10., 10. ));
+
+//  Mixed (2)
+    BOOST_CHECK_EQUAL (   5.f, ba::clamp (   5.f, -10, 10 ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -10.f, -10, 10 ));
+    BOOST_CHECK_EQUAL ( -10.f, ba::clamp ( -15.f, -10, 10 ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  10.f, -10, 10 ));
+    BOOST_CHECK_EQUAL (  10.f, ba::clamp (  15.f, -10, 10 ));
+}
+
+void test_custom()
+{
+
+//  Inside the range, equal to the endpoints, and outside the endpoints.
+    BOOST_CHECK_EQUAL ( custom( 3), ba::clamp ( custom( 3), custom(1), custom(10)));
+    BOOST_CHECK_EQUAL ( custom( 1), ba::clamp ( custom( 1), custom(1), custom(10)));
+    BOOST_CHECK_EQUAL ( custom( 1), ba::clamp ( custom( 0), custom(1), custom(10)));
+    BOOST_CHECK_EQUAL ( custom(10), ba::clamp ( custom(10), custom(1), custom(10)));
+    BOOST_CHECK_EQUAL ( custom(10), ba::clamp ( custom(11), custom(1), custom(10)));
+
+    BOOST_CHECK_EQUAL ( custom( 3), ba::clamp ( custom( 3), custom(1), custom(10), customLess ));
+    BOOST_CHECK_EQUAL ( custom( 1), ba::clamp ( custom( 1), custom(1), custom(10), customLess ));
+    BOOST_CHECK_EQUAL ( custom( 1), ba::clamp ( custom( 0), custom(1), custom(10), customLess ));
+    BOOST_CHECK_EQUAL ( custom(10), ba::clamp ( custom(10), custom(1), custom(10), customLess ));
+    BOOST_CHECK_EQUAL ( custom(10), ba::clamp ( custom(11), custom(1), custom(10), customLess ));
+
+//  Fail!!
+//  BOOST_CHECK_EQUAL ( custom(1), ba::clamp ( custom(11), custom(1), custom(10)));
+}
+
+#define elementsof(v)   (sizeof (v) / sizeof (v[0]))
+#define a_begin(v)      (&v[0])
+#define a_end(v)        (v + elementsof (v))
+#define a_range(v)      v
+#define b_e(v)          a_begin(v),a_end(v)
+
+void test_int_range ()
+{
+    int inputs []  = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 19, 99, 999, -1, -3, -99, 234234 };
+    int outputs [] = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10,  10, -1, -1, -1,  10 };
+    std::vector<int> results;
+    std::vector<int> in_v;
+    
+    std::copy ( a_begin(inputs), a_end(inputs), std::back_inserter ( in_v ));
+    
+    ba::clamp_range ( a_begin(inputs), a_end(inputs), std::back_inserter ( results ), -1, 10 );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+    ba::clamp_range ( in_v.begin (), in_v.end (), std::back_inserter ( results ), -1, 10 );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+
+    ba::clamp_range ( a_begin(inputs), a_end(inputs), std::back_inserter ( results ), 10, -1, intGreater );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+    ba::clamp_range ( in_v.begin (), in_v.end (), std::back_inserter ( results ), 10, -1, intGreater );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+
+    ba::clamp_range ( a_range(inputs), std::back_inserter ( results ), -1, 10 );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+    ba::clamp_range ( in_v, std::back_inserter ( results ), -1, 10 );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+        
+    ba::clamp_range ( a_range(inputs), std::back_inserter ( results ), 10, -1, intGreater );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+    ba::clamp_range ( in_v, std::back_inserter ( results ), 10, -1, intGreater );
+    BOOST_CHECK ( std::equal ( results.begin(), results.end (), outputs ));
+    results.clear ();
+    
+    int junk[elementsof(inputs)];
+    ba::clamp_range ( inputs, junk, 10, -1, intGreater );
+    BOOST_CHECK ( std::equal ( b_e(junk), outputs ));
+}
+
+void test_constexpr()
+{
+
+//  Inside the range, equal to the endpoints, and outside the endpoints.
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (3  == ba::clamp (  3, 1, 10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1  == ba::clamp (  1, 1, 10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1  == ba::clamp (  0, 1, 10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10 == ba::clamp ( 10, 1, 10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10 == ba::clamp ( 11, 1, 10 ));
+        BOOST_CHECK(check_max_out);
+    }
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (3  == ba::clamp (  3, 10, 1, intGreater ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1  == ba::clamp (  1, 10, 1, intGreater ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1  == ba::clamp (  0, 10, 1, intGreater ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10 == ba::clamp ( 10, 10, 1, intGreater ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10 == ba::clamp ( 11, 10, 1, intGreater ));
+        BOOST_CHECK(check_max_out);
+    }
+
+//  Negative numbers
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (-3  == ba::clamp  (  -3, -10, -1 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (-1  == ba::clamp  (  -1, -10, -1 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (-1  == ba::clamp  (   0, -10, -1 ));
+        BOOST_CHECK(check_max_out);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (-10 == ba::clamp ( -10, -10, -1 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (-10 == ba::clamp ( -11, -10, -1 ));
+        BOOST_CHECK(check_min_out);
+    }
+
+//  Mixed positive and negative numbers
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5   == ba::clamp (   5, -10, 10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (-10 == ba::clamp ( -10, -10, 10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (-10 == ba::clamp ( -15, -10, 10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10  == ba::clamp (  10, -10, 10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10  == ba::clamp (  15, -10, 10 ));
+        BOOST_CHECK(check_max_out);
+    }
+//  Unsigned
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1U, 10U ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1U, 10U ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1U, 10U ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1U, 10U ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1U, 10U ));
+        BOOST_CHECK(check_max_out);
+    }
+//  Mixed (1)
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1,  10 ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1,  10 ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1,  10 ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1,  10 ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1,  10 ));
+        BOOST_CHECK(check_max_out);
+    }  
+//  Mixed (3)
+    {
+        BOOST_CXX14_CONSTEXPR bool check_inside  = (5U  == ba::clamp (  5U, 1,  10. ));
+        BOOST_CHECK(check_inside);
+        BOOST_CXX14_CONSTEXPR bool check_min     = (1U  == ba::clamp (  1U, 1,  10. ));
+        BOOST_CHECK(check_min);
+        BOOST_CXX14_CONSTEXPR bool check_min_out = (1U  == ba::clamp (  0U, 1,  10. ));
+        BOOST_CHECK(check_min_out);
+        BOOST_CXX14_CONSTEXPR bool check_max     = (10U == ba::clamp ( 10U, 1,  10. ));
+        BOOST_CHECK(check_max);
+        BOOST_CXX14_CONSTEXPR bool check_max_out = (10U == ba::clamp ( 15U, 1,  10. ));
+        BOOST_CHECK(check_max_out);
+    }
+    {
+        BOOST_CXX14_CONSTEXPR short foo = 50;
+        BOOST_CXX14_CONSTEXPR bool check_float   = ( 56    == ba::clamp ( foo, 56.9, 129 ));
+        BOOST_CHECK(check_float);
+        BOOST_CXX14_CONSTEXPR bool check_over    = ( 24910 == ba::clamp ( foo, 12345678, 123456999 ));
+        BOOST_CHECK(check_over);
+    }
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    test_ints ();
+    test_floats ();
+    test_custom ();
+    
+    test_int_range ();
+
+    test_constexpr ();
+//    test_float_range ();
+//    test_custom_range ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/copy_if_test1.cpp

@@ -0,0 +1,256 @@
+/* 
+   Copyright (c) Marshall Clow 2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/copy_if.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <string>
+#include <iostream>
+#include <vector>
+#include <list>
+
+#include <boost/algorithm/cxx11/all_of.hpp>
+#include <boost/algorithm/cxx14/equal.hpp>
+#include <boost/algorithm/cxx11/none_of.hpp>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+BOOST_CXX14_CONSTEXPR bool is_true  ( int v ) { return true; }
+BOOST_CXX14_CONSTEXPR bool is_false ( int v ) { return false; }
+BOOST_CXX14_CONSTEXPR bool is_even  ( int v ) { return v % 2 == 0; }
+BOOST_CXX14_CONSTEXPR bool is_odd   ( int v ) { return v % 2 == 1; }
+BOOST_CXX14_CONSTEXPR bool is_zero  ( int v ) { return v == 0; }
+
+
+template <typename Container>
+void test_copy_if ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    std::vector<value_type> v;
+    
+//  None of the elements
+    v.clear ();
+    ba::copy_if ( c.begin (), c.end (), back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == 0 );
+
+    v.clear ();
+    ba::copy_if ( c, back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == 0 );
+
+//  All the elements
+    v.clear ();
+    ba::copy_if ( c.begin (), c.end (), back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    v.clear ();
+    ba::copy_if ( c, back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+//  Some of the elements
+    v.clear ();
+    ba::copy_if ( c.begin (), c.end (), back_inserter ( v ), is_even );
+    BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even ));
+    BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even ));
+
+    v.clear ();
+    ba::copy_if ( c, back_inserter ( v ), is_even );
+    BOOST_CHECK ( v.size () == (size_t) std::count_if ( c.begin (), c.end (), is_even ));
+    BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even ));
+    }
+
+
+template <typename Container>
+void test_copy_while ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    typename Container::const_iterator it;
+    std::vector<value_type> v;
+    
+//  None of the elements
+    v.clear ();
+    ba::copy_while ( c.begin (), c.end (), back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == 0 );
+    
+    v.clear ();
+    ba::copy_while ( c, back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == 0 );
+
+//  All the elements
+    v.clear ();
+    ba::copy_while ( c.begin (), c.end (), back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    v.clear ();
+    ba::copy_while ( c, back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+//  Some of the elements
+    v.clear ();
+    it = ba::copy_while ( c.begin (), c.end (), back_inserter ( v ), is_even ).first;
+    BOOST_CHECK ( v.size () == (size_t) std::distance ( c.begin (), it ));
+    BOOST_CHECK ( it == c.end () || !is_even ( *it ));
+    BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even ));
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    v.clear ();
+    it = ba::copy_while ( c, back_inserter ( v ), is_even ).first;
+    BOOST_CHECK ( v.size () == (size_t) std::distance ( c.begin (), it ));
+    BOOST_CHECK ( it == c.end () || !is_even ( *it ));
+    BOOST_CHECK ( ba::all_of ( v.begin (), v.end (), is_even ));
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+    }
+
+template <typename Container>
+void test_copy_until ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    typename Container::const_iterator it;
+    std::vector<value_type> v;
+    
+//  None of the elements
+    v.clear ();
+    ba::copy_until ( c.begin (), c.end (), back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == 0 );
+
+    v.clear ();
+    ba::copy_until ( c, back_inserter ( v ), is_true);
+    BOOST_CHECK ( v.size () == 0 );
+
+//  All the elements
+    v.clear ();
+    ba::copy_until ( c.begin (), c.end (), back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    v.clear ();
+    ba::copy_until ( c, back_inserter ( v ), is_false);
+    BOOST_CHECK ( v.size () == c.size ());
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+//  Some of the elements
+    v.clear ();
+    it = ba::copy_until ( c.begin (), c.end (), back_inserter ( v ), is_even ).first;
+    BOOST_CHECK ( v.size () == (size_t) std::distance ( c.begin (), it ));
+    BOOST_CHECK ( it == c.end () || is_even ( *it ));
+    BOOST_CHECK ( ba::none_of ( v.begin (), v.end (), is_even ));
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    v.clear ();
+    it = ba::copy_until ( c, back_inserter ( v ), is_even ).first;
+    BOOST_CHECK ( v.size () == (size_t) std::distance ( c.begin (), it ));
+    BOOST_CHECK ( it == c.end () || is_even ( *it ));
+    BOOST_CHECK ( ba::none_of ( v.begin (), v.end (), is_even ));
+    BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+    }
+
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_if() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_if ( from, to, out, is_false ); // copy none
+    res = (res && out == out_data);
+    
+    out = ba::copy_if ( from, to, out, is_true ); // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_while() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_while ( from, to, out, is_false ).second; // copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+    
+    out = ba::copy_while ( from, to, out, is_true ).second; // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+
+BOOST_CXX14_CONSTEXPR inline bool constexpr_test_copy_until() {
+    const int sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    out = ba::copy_until ( from, to, out, is_true ).second; // copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+    
+    out = ba::copy_until ( from, to, out, is_false ).second; // copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+    
+    
+void test_sequence1 () {
+    std::vector<int> v;
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_copy_if ( v );
+    test_copy_while ( v );
+    test_copy_until ( v );
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_if = constexpr_test_copy_if();
+    BOOST_CHECK ( constexpr_res_if );
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_while = constexpr_test_copy_while();
+    BOOST_CHECK ( constexpr_res_while );
+    BOOST_CXX14_CONSTEXPR bool constexpr_res_until = constexpr_test_copy_until();
+    BOOST_CHECK ( constexpr_res_until );
+    
+    std::list<int> l;
+    for ( int i = 25; i > 15; --i )
+        l.push_back ( i );
+    test_copy_if ( l );
+    test_copy_while ( l );
+    test_copy_until ( l );
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/copy_n_test1.cpp

@@ -0,0 +1,118 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/copy_n.hpp>
+#include <boost/algorithm/cxx14/equal.hpp>
+#include <boost/algorithm/cxx11/all_of.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+BOOST_CXX14_CONSTEXPR bool is_zero( int v ) { return v == 0; }
+
+template <typename Container>
+void test_sequence ( Container const &c ) {
+
+    typedef typename Container::value_type value_type;
+    std::vector<value_type> v;
+    
+//  Copy zero elements
+    v.clear ();
+    ba::copy_n ( c.begin (), 0, back_inserter ( v ));
+    BOOST_CHECK ( v.size () == 0 );
+    ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
+    BOOST_CHECK ( v.size () == 0 );
+
+    if ( c.size () > 0 ) {  
+    //  Just one element
+        v.clear ();
+        ba::copy_n ( c.begin (), 1, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == 1 );
+        BOOST_CHECK ( v[0] == *c.begin ());
+        
+        v.clear ();
+        ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == 1 );
+        BOOST_CHECK ( v[0] == *c.begin ());
+
+    //  Half the elements
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size () / 2);
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+
+    //  Half the elements + 1
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+    
+    //  All the elements
+        v.clear ();
+        ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
+        BOOST_CHECK ( v.size () == c.size ());
+        BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
+        }
+    }
+
+
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr() {
+    const size_t sz = 64;
+    int in_data[sz] = {0};
+    bool res = true;
+    
+    const int* from = in_data;
+    const int* to = in_data + sz;
+    
+    int out_data[sz] = {0};
+    int* out = out_data;
+    
+    out = ba::copy_n ( from, 0, out ); // Copy none
+    res = (res && out == out_data && ba::all_of(out, out + sz, is_zero));
+
+    out = ba::copy_n ( from, sz, out ); // Copy all
+    res = (res && out == out_data + sz
+           && ba::equal( input_iterator<const int *>(out_data),  input_iterator<const int *>(out_data + sz), 
+                         input_iterator<const int *>(from), input_iterator<const int *>(to)));
+    
+    return res;
+    }
+    
+    
+void test_sequence1 () {
+    std::vector<int> v;
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_sequence  ( v );
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr();
+    BOOST_CHECK(constexpr_res);
+    
+    std::list<int> l;
+    for ( int i = 25; i > 15; --i )
+        l.push_back ( i );
+    test_sequence  ( l );   
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/empty_search_test.cpp

@@ -0,0 +1,81 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <string>
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    const std::string cs;
+    std::string estr;
+    std::string str ( "abc" );
+    
+//  empty corpus, empty pattern
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_search (
+            cs.begin (), cs.end (), estr.begin (), estr.end ())
+        == std::make_pair(cs.begin(), cs.begin())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_horspool_search (
+            cs.begin (), cs.end (), estr.begin (), estr.end ())
+        == std::make_pair(cs.begin(), cs.begin())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::knuth_morris_pratt_search (
+            cs.begin (), cs.end (), estr.begin (), estr.end ())
+        == std::make_pair(cs.begin(), cs.begin())
+        );
+
+//  empty corpus, non-empty pattern
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_search (
+            estr.begin (), estr.end (), str.begin (), str.end ())
+        == std::make_pair(estr.end(), estr.end())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_horspool_search (
+            estr.begin (), estr.end (), str.begin (), str.end ())
+        == std::make_pair(estr.end(), estr.end())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::knuth_morris_pratt_search (
+            estr.begin (), estr.end (), str.begin (), str.end ())
+        == std::make_pair(estr.end(), estr.end())
+        );
+
+//  non-empty corpus, empty pattern
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_search (
+            str.begin (), str.end (), estr.begin (), estr.end ())
+        == std::make_pair(str.begin(), str.begin())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::boyer_moore_horspool_search (
+            str.begin (), str.end (), estr.begin (), estr.end ())
+        == std::make_pair(str.begin(), str.begin())
+        );
+
+    BOOST_CHECK ( 
+        boost::algorithm::knuth_morris_pratt_search (
+            str.begin (), str.end (), estr.begin (), estr.end ())
+        == std::make_pair(str.begin(), str.begin())
+        );
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/equal_test.cpp

@@ -0,0 +1,165 @@
+/* 
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx14/equal.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+template <typename T>
+BOOST_CXX14_CONSTEXPR bool eq ( const T& a, const T& b ) { return a == b; }
+
+template <typename T>
+bool never_eq ( const T&, const T& ) { return false; }
+
+int comparison_count = 0;
+template <typename T>
+bool counting_equals ( const T &a, const T &b ) {
+    ++comparison_count;
+    return a == b;
+    }
+
+namespace ba = boost::algorithm;
+
+void test_equal ()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    int num[] = { 1, 1, 2, 3, 5 };
+    const int sz = sizeof (num)/sizeof(num[0]);
+    
+    
+//  Empty sequences are equal to each other, but not to non-empty sequences
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num), 
+                              input_iterator<int *>(num),     input_iterator<int *>(num)));
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num), 
+                              input_iterator<int *>(num),     input_iterator<int *>(num),
+                              never_eq<int> ));
+    BOOST_CHECK ( ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num),
+                              never_eq<int> ));
+                              
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num), 
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1)));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num + 1), input_iterator<int *>(num + 2), 
+                              input_iterator<int *>(num),     input_iterator<int *>(num)));
+    BOOST_CHECK (!ba::equal ( random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + 2), 
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num)));
+
+//  Single element sequences are equal if they contain the same value
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1)));
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              eq<int> ));
+    BOOST_CHECK ( ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+                              eq<int> ));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              never_eq<int> ));
+    BOOST_CHECK (!ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num + 1),
+                              never_eq<int> ));
+
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              input_iterator<int *>(num + 1), input_iterator<int *>(num + 2)));
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              input_iterator<int *>(num + 1), input_iterator<int *>(num + 2),
+                              eq<int> ));
+
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num + 2), input_iterator<int *>(num + 3), 
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1)));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num + 2), input_iterator<int *>(num + 3),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + 1),
+                              eq<int> ));
+                              
+//  Identical long sequences are equal. 
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz)));
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              eq<int> ));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              never_eq<int> ));
+    BOOST_CHECK ( ba::equal ( input_iterator<int *>(num),             input_iterator<int *>(num + sz),
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                              eq<int> ));
+
+//  different sequences are different
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz)));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              eq<int> ));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz - 1)));
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz - 1),
+                              eq<int> ));
+
+//  When there's a cheap check, bail early
+    comparison_count = 0;
+    BOOST_CHECK (!ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                              random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz - 1),
+                              counting_equals<int> ));
+    BOOST_CHECK ( comparison_count == 0 );
+//  And when there's not, we can't
+    comparison_count = 0;
+    BOOST_CHECK (!ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                              input_iterator<int *>(num),     input_iterator<int *>(num + sz - 1),
+                              counting_equals<int> ));
+    BOOST_CHECK ( comparison_count > 0 );
+    
+}
+
+
+BOOST_CXX14_CONSTEXPR bool test_constexpr_equal() {
+    int num[] = { 1, 1, 2, 3, 5};
+    const int sz = sizeof (num)/sizeof(num[0]);
+    bool res = true;
+//  Empty sequences are equal to each other
+    res = (   ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num), 
+                          input_iterator<int *>(num),     input_iterator<int *>(num))
+//  Identical long sequences are equal                         
+           && ba::equal ( input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                          input_iterator<int *>(num),     input_iterator<int *>(num + sz),
+                          eq<int> )
+//  Different sequences are different
+           && !ba::equal ( input_iterator<int *>(num + 1), input_iterator<int *>(num + sz),
+                           input_iterator<int *>(num),     input_iterator<int *>(num + sz))
+          );
+#ifdef __cpp_lib_array_constexpr // or cpp17 compiler
+//  Turn on tests for random_access_iterator, because std functions used in equal are marked constexpr_res
+    res = ( res 
+//  Empty sequences are equal to each other
+           && ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
+                          random_access_iterator<int *>(num),     random_access_iterator<int *>(num))
+//  Identical long sequences are equal                         
+           && ba::equal ( random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                          random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+                          eq<int> )
+//  Different sequences are different
+           && !ba::equal ( random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + sz),
+                           random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz))
+          );
+#endif
+    return res;
+  }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_equal ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr_equal ();
+  BOOST_CHECK (constexpr_res);
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/exclusive_scan_test.cpp

@@ -0,0 +1,72 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+#include <numeric>
+#include <algorithm>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/iota.hpp>
+#include <boost/algorithm/cxx17/exclusive_scan.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+int triangle(int n) { return n*(n+1)/2; }
+
+void basic_tests_init()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::exclusive_scan(v.begin(), v.end(), v.begin(), 50);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 50 + (int) i * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::exclusive_scan(v.begin(), v.end(), v.begin(), 30);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 30 + triangle(i-1));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::exclusive_scan(v.begin(), v.end(), v.begin(), 40);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 40 + triangle(i));
+    }
+
+}
+
+void test_exclusive_scan_init()
+{
+	basic_tests_init();
+}
+
+void test_exclusive_scan_init_op()
+{
+	BOOST_CHECK(true);
+}
+
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_exclusive_scan_init();
+  test_exclusive_scan_init_op();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/find_backward_test.cpp

@@ -0,0 +1,420 @@
+/* 
+   Copyright (c) T. Zachary Laine 2018.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+#include <iostream>
+
+#include <boost/algorithm/find_backward.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <list>
+
+
+namespace ba = boost::algorithm;
+
+template <typename Container>
+struct dist_t
+{
+    dist_t(Container & cont) : cont_(cont) {}
+    template<typename Iter>
+    std::ptrdiff_t operator()(Iter it) const
+    {
+        return std::distance(cont_.begin(), it);
+    }
+
+    Container & cont_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_backward(from, to, 1); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_backward(in_data, 1); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_backward(from, to, 6); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_backward(in_data, 6); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_backward(from, to, 3); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_backward(in_data, 3); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), 0)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), 100)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), v1.back())),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1.begin(), v1.end(), v1.front())), 0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, 0)), v1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, 100)), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(v1, v1.back())), v1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(v1, v1.front())), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), 0)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), 100)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), l1.back())),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1.begin(), l1.end(), l1.front())), 0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, 0)), l1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, 100)), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_backward(l1, l1.back())), l1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_backward(l1, l1.front())), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_backward();
+    BOOST_CHECK(ce_result);
+}
+
+struct equals
+{
+    BOOST_CXX14_CONSTEXPR equals(int n) : n_(n) {}
+    BOOST_CXX14_CONSTEXPR bool operator()(int i) { return i == n_; }
+    int n_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_if_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_if_backward(from, to, equals(1)); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_if_backward(in_data, equals(1)); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_if_backward(from, to, equals(6)); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_if_backward(in_data, equals(6)); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_if_backward(from, to, equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_if_backward(in_data, equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_if_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(0))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(100))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1.begin(), v1.end(), equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(
+                ba::find_if_backward(v1.begin(), v1.end(), equals(v1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_if_backward(v1, equals(0))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(100))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(v1.back()))), v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(v1, equals(v1.front()))), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(0))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(100))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1.begin(), l1.end(), equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(
+                ba::find_if_backward(l1.begin(), l1.end(), equals(l1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_if_backward(l1, equals(0))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(100))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(l1.back()))), l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_backward(l1, equals(l1.front()))), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_if_backward();
+    BOOST_CHECK(ce_result);
+}
+
+struct not_equals
+{
+    BOOST_CXX14_CONSTEXPR not_equals(int n) : n_(n) {}
+    BOOST_CXX14_CONSTEXPR bool operator()(int i) { return i != n_; }
+    int n_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_if_not_backward()
+{
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_if_not_backward(from, to, not_equals(1)); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_if_not_backward(in_data, not_equals(1)); // stops on first
+    res = (res && start == from);
+
+    const int* end = ba::find_if_not_backward(from, to, not_equals(6)); // stops on the end
+    res = (res && end == to);
+
+    end = ba::find_if_not_backward(in_data, not_equals(6)); // stops on the end
+    res = (res && end == to);
+
+    const int* three = ba::find_if_not_backward(from, to, not_equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_if_not_backward(in_data, not_equals(3)); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_find_if_not_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1.begin(), v1.end(), not_equals(0))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(100))),
+            v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                v1.begin(), v1.end(), not_equals(v1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(0))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(100))), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(v1.back()))),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(v1, not_equals(v1.front()))), 0);
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1.begin(), l1.end(), not_equals(0))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(100))),
+            l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(
+                l1.begin(), l1.end(), not_equals(l1.front()))),
+            0);
+
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(0))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(100))), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(l1.back()))),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_if_not_backward(l1, not_equals(l1.front()))), 0);
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_if_not_backward();
+    BOOST_CHECK(ce_result);
+}
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr_not_backward()
+{
+    int in_data[] = {1, 5, 5, 5, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_not_backward(from, to, 5); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_not_backward(in_data, 5); // stops on first
+    res = (res && start == from);
+
+    const int in_data_2[] = {6, 6, 6, 6, 6};
+    const int* end = ba::find_not_backward(in_data_2, in_data_2 + 5, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    end = ba::find_not_backward(in_data_2, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    return res;
+}
+
+void test_find_not_backward()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 0; i < 5; ++i)
+            v1.push_back(0);
+        for (int i = 0; i < 5; ++i)
+            v1.push_back(1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 1)), 4);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 0)),
+            v1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 2)),
+            v1.size() - 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 1)), 4);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 0)), v1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 2)), v1.size() - 1);
+
+        v1.resize(5);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(v1.begin(), v1.end(), 0)), v1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(v1, 0)), v1.size());
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 0; i < 5; ++i)
+            l1.push_back(0);
+        for (int i = 0; i < 5; ++i)
+            l1.push_back(1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 1)), 4);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 0)),
+            l1.size() - 1);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 2)),
+            l1.size() - 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 1)), 4);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 0)), l1.size() - 1);
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 2)), l1.size() - 1);
+
+        l1.resize(5);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not_backward(l1.begin(), l1.end(), 0)), l1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not_backward(l1, 0)), l1.size());
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr_not_backward();
+    BOOST_CHECK(ce_result);
+}
+
+BOOST_AUTO_TEST_CASE(test_main)
+{
+    test_find_backward();
+    test_find_if_backward();
+    test_find_if_not_backward();
+    test_find_not_backward();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/find_if_not_test1.cpp

@@ -0,0 +1,114 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/find_if_not.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+BOOST_CXX14_CONSTEXPR bool is_true  ( int v ) { return true; }
+BOOST_CXX14_CONSTEXPR bool is_false ( int v ) { return false; }
+BOOST_CXX14_CONSTEXPR bool is_not_three ( int v ) { return v != 3; }
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr() {
+    int in_data[] = {1, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+    
+    const int* start = ba::find_if_not (from, to, is_false); // stops on first
+    res = (res && start == from);
+    
+    const int* end = ba::find_if_not(from, to, is_true); // stops on the end
+    res = (res && end == to);
+    
+    const int* three = ba::find_if_not(from, to, is_not_three); // stops on third element
+    res = (res && three == in_data + 2);
+    
+    return res;
+}
+
+template <typename Container>
+typename Container::iterator offset_to_iter ( Container &v, int offset ) {
+    typename Container::iterator retval;
+    
+    if ( offset >= 0 ) {
+        retval = v.begin ();
+        std::advance ( retval, offset );
+        }
+    else {
+        retval = v.end ();
+        std::advance ( retval, offset + 1 );
+        }
+    return retval;
+    }
+
+template <typename Container, typename Predicate>
+void test_sequence ( Container &v, Predicate comp, int expected ) {
+    typename Container::iterator res, exp;
+    
+    res = ba::find_if_not ( v.begin (), v.end (), comp );
+    exp = offset_to_iter ( v, expected );
+    std::cout << "Expected(1): " << std::distance ( v.begin (), exp ) 
+              <<       ", got: " << std::distance ( v.begin (), res ) << std::endl;
+    BOOST_CHECK ( exp == res );
+    }
+
+template <typename T>
+struct less_than {
+public:
+    less_than ( T foo ) : val ( foo ) {}
+    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+    };
+
+
+void test_sequence1 () {
+    std::vector<int> v;
+    
+    v.clear ();
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_sequence ( v, less_than<int>(3),  0 ); // no elements
+    test_sequence ( v, less_than<int>(6),  1 );    // only the first element
+    test_sequence ( v, less_than<int>(10), 5 );
+    test_sequence ( v, less_than<int>(99), -1 );   // all elements satisfy 
+
+//  With bidirectional iterators.
+    std::list<int> l;
+    for ( int i = 5; i < 15; ++i )
+        l.push_back ( i );
+    test_sequence ( l, less_than<int>(3),  0 ); // no elements
+    test_sequence ( l, less_than<int>(6),  1 );    // only the first element
+    test_sequence ( l, less_than<int>(10), 5 );
+    test_sequence ( l, less_than<int>(99), -1 );   // all elements satisfy 
+
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/find_not_test.cpp

@@ -0,0 +1,134 @@
+/* 
+   Copyright (c) T. Zachary Laine 2018.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+#include <iostream>
+
+#include <boost/algorithm/find_not.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <list>
+
+
+namespace ba = boost::algorithm;
+
+template <typename Container>
+struct dist_t
+{
+    dist_t(Container & cont) : cont_(cont) {}
+    template<typename Iter>
+    std::ptrdiff_t operator()(Iter it) const
+    {
+        return std::distance(cont_.begin(), it);
+    }
+
+    Container & cont_;
+};
+
+BOOST_CXX14_CONSTEXPR bool check_constexpr()
+{
+    int in_data[] = {2, 2, 3, 4, 5};
+    bool res = true;
+
+    const int* from = in_data;
+    const int* to = in_data + 5;
+
+    const int* start = ba::find_not(from, to, 1); // stops on first
+    res = (res && start == from);
+
+    start = ba::find_not(in_data, 1); // stops on first
+    res = (res && start == from);
+
+    int in_data_2[] = {6, 6, 6, 6, 6};
+    const int* end = ba::find_not(in_data_2, in_data_2 + 5, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    end = ba::find_not(in_data_2, 6); // stops on the end
+    res = (res && end == in_data_2 + 5);
+
+    const int* three = ba::find_not(from, to, 2); // stops on third element
+    res = (res && three == in_data + 2);
+
+    three = ba::find_not(in_data, 2); // stops on third element
+    res = (res && three == in_data + 2);
+
+    return res;
+}
+
+void test_sequence()
+{
+    {
+        std::vector<int> v1;
+        const dist_t<std::vector<int> > dist(v1);
+
+        for (int i = 5; i < 15; ++i)
+            v1.push_back(i);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1.begin(), v1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.back())), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.front())), 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.back())), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.front())), 1);
+
+        v1 = std::vector<int>(10, 2);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1.begin(), v1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.back())), v1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(v1.begin(), v1.end(), v1.front())), v1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.back())), v1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_not(v1, v1.front())), v1.size());
+    }
+
+    //  With bidirectional iterators.
+    {
+        std::list<int> l1;
+        const dist_t<std::list<int> > dist(l1);
+
+        for (int i = 5; i < 15; ++i)
+            l1.push_back(i);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1.begin(), l1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.back())), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.front())), 1);
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.back())), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.front())), 1);
+
+        l1.clear();
+        for (int i = 0; i < 10; ++i)
+            l1.push_back(2);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1.begin(), l1.end(), 0)), 0);
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.back())), l1.size());
+        BOOST_CHECK_EQUAL(
+            dist(ba::find_not(l1.begin(), l1.end(), l1.front())), l1.size());
+
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, 0)), 0);
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.back())), l1.size());
+        BOOST_CHECK_EQUAL(dist(ba::find_not(l1, l1.front())), l1.size());
+    }
+
+    BOOST_CXX14_CONSTEXPR bool ce_result = check_constexpr();
+    BOOST_CHECK(ce_result);
+}
+
+
+BOOST_AUTO_TEST_CASE(test_main)
+{
+    test_sequence();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/for_each_n_test.cpp

@@ -0,0 +1,66 @@
+/*
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx17/for_each_n.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+struct for_each_test
+{
+    for_each_test() {}
+    static int count;
+    void operator()(int& i) {++i; ++count;}
+};
+
+int for_each_test::count = 0;
+
+void test_for_each_n ()
+{
+    typedef input_iterator<int*> Iter;
+    int ia[] = {0, 1, 2, 3, 4, 5};
+    const unsigned s = sizeof(ia)/sizeof(ia[0]);
+
+    {
+	for_each_test::count = 0;
+    Iter it = ba::for_each_n(Iter(ia), 0, for_each_test());
+    BOOST_CHECK(it == Iter(ia));
+    BOOST_CHECK(for_each_test::count == 0);
+    }
+
+    {
+	for_each_test::count = 0;
+    Iter it = ba::for_each_n(Iter(ia), s, for_each_test());
+
+    BOOST_CHECK(it == Iter(ia+s));
+    BOOST_CHECK(for_each_test::count == s);
+    for (unsigned i = 0; i < s; ++i)
+        BOOST_CHECK(ia[i] == static_cast<int>(i+1));
+    }
+
+    {
+	for_each_test::count = 0;
+    Iter it = ba::for_each_n(Iter(ia), 1, for_each_test());
+
+    BOOST_CHECK(it == Iter(ia+1));
+    BOOST_CHECK(for_each_test::count == 1);
+    for (unsigned i = 0; i < 1; ++i)
+        BOOST_CHECK(ia[i] == static_cast<int>(i+2));
+    }
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_for_each_n ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/gather_fail1.cpp

@@ -0,0 +1,38 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/gather.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+#include "iterator_test.hpp"
+
+namespace ba = boost::algorithm;
+
+bool is_ten  ( int i ) { return i == 10; }
+
+void test_sequence1 () {
+    std::vector<int> v;
+    typedef input_iterator<std::vector<int>::iterator> II;    
+
+//  This should fail to compile, since gather doesn't work with input iterators
+    (void) ba::gather ( II( v.begin ()), II( v.end ()), II( v.begin ()), is_ten );
+    }
+
+
+int main ()
+{
+  test_sequence1 ();
+  return 0;
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/gather_test1.cpp

@@ -0,0 +1,138 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/gather.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+#include "iterator_test.hpp"
+
+namespace ba = boost::algorithm;
+
+template <typename Container>
+void print ( const char *prompt, const Container &c ) {
+    std::cout << prompt << " { ";
+    std::copy ( c.begin (), c.end (), std::ostream_iterator<typename Container::value_type>(std::cout, " "));
+    std::cout << std::endl;
+    }
+
+template <typename Iterator, typename Predicate>
+void test_iterators ( Iterator first, Iterator last, Predicate comp, std::size_t offset ) {
+//  Create the pivot point
+    Iterator off = first;
+    std::advance(off, offset);
+        
+//  Gather the elements
+    std::pair<Iterator, Iterator> res = ba::gather ( first, last, off, comp );
+
+//  We should now have three sequences, any of which may be empty:
+//      * [begin .. result.first)         - items that do not satisfy the predicate
+//      * [result.first .. result.second) - items that do satisfy the predicate
+//      * [result.second .. end)          - items that do not satisfy the predicate
+    Iterator iter = first;
+    for ( ; iter != res.first; ++iter )
+        BOOST_CHECK ( !comp ( *iter ));
+    for ( ; iter != res.second; ++iter)
+        BOOST_CHECK ( comp ( *iter ));
+    for ( ; iter != last; ++iter )
+        BOOST_CHECK ( !comp ( *iter ));
+    }
+
+template <typename Container, typename Predicate>
+void test_iterator_types ( const Container &c, Predicate comp, std::size_t offset ) {
+    typedef std::vector<typename Container::value_type> vec;
+
+    typedef bidirectional_iterator<typename vec::iterator> BDI;
+    typedef random_access_iterator<typename vec::iterator> RAI;
+    
+    vec v;
+    v.assign ( c.begin (), c.end ());
+    test_iterators ( BDI ( v.begin ()), BDI ( v.end ()), comp, offset );
+    v.assign ( c.begin (), c.end ());
+    test_iterators ( RAI ( v.begin ()), RAI ( v.end ()), comp, offset );
+    }
+
+
+template <typename T>
+struct less_than {
+public:
+//    typedef T argument_type;
+//    typedef bool result_type;
+
+    less_than ( T foo ) : val ( foo ) {}
+    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+    };
+
+bool is_even ( int i ) { return i % 2 == 0; }
+bool is_ten  ( int i ) { return i == 10; }
+
+void test_sequence1 () {
+    std::vector<int> v;
+    
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_iterator_types ( v, less_than<int>(10),  0 );                  // at beginning
+    test_iterator_types ( v, less_than<int>(10),  5 );
+    test_iterator_types ( v, less_than<int>(10), v.size () - 1 );       // at end
+
+    test_iterator_types ( v, is_even, 0 );
+    test_iterator_types ( v, is_even, 5 );
+    test_iterator_types ( v, is_even, v.size () - 1 );
+
+//  Exactly one element in the sequence matches
+    test_iterator_types ( v, is_ten, 0 );
+    test_iterator_types ( v, is_ten, 5 );
+    test_iterator_types ( v, is_ten, v.size () - 1 );
+
+//  Everything in the sequence matches
+    test_iterator_types ( v, less_than<int>(99),  0 );
+    test_iterator_types ( v, less_than<int>(99),  5 );
+    test_iterator_types ( v, less_than<int>(99), v.size () - 1 );
+    
+//  Nothing in the sequence matches
+    test_iterator_types ( v, less_than<int>(0),  0 );
+    test_iterator_types ( v, less_than<int>(0),  5 );
+    test_iterator_types ( v, less_than<int>(0), v.size () - 1 );
+    
+//  All the elements in the sequence are the same
+    v.clear ();
+    for ( int i = 0; i < 11; ++i )
+        v.push_back ( 10 );
+    
+//  Everything in the sequence matches
+    test_iterator_types ( v, is_ten, 0 );
+    test_iterator_types ( v, is_ten, 5 );
+    test_iterator_types ( v, is_ten, v.size () - 1 );
+
+//  Nothing in the sequence matches
+    test_iterator_types ( v, less_than<int>(5),  0 );
+    test_iterator_types ( v, less_than<int>(5),  5 );
+    test_iterator_types ( v, less_than<int>(5), v.size () - 1 );
+
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/hex_fail1.cpp

@@ -0,0 +1,25 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+//  should not compile: vector is not an integral type
+int main( int , char* [] )
+{
+  std::vector<float> v;
+  std::string out;
+  boost::algorithm::unhex ( out, std::back_inserter(v));
+
+  return 0;
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/hex_test1.cpp

@@ -0,0 +1,194 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/algorithm/string/case_conv.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+
+
+template<typename String>
+void test_to_hex ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, std::back_inserter ( one ));
+        boost::algorithm::hex ( arg, std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::unhex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh, std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+template<typename String>
+void test_to_hex_lower ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::hex_lower ( *p, std::back_inserter ( one ));
+        boost::algorithm::hex_lower ( arg, std::back_inserter ( two ));
+        boost::algorithm::hex_lower ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex_lower ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::unhex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh, std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+
+template<typename String>
+void test_from_hex_success ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p, std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg, std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::hex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::hex ( argh, std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( argh );
+        boost::algorithm::to_lower( arg );
+        boost::algorithm::to_lower( one );
+        boost::algorithm::to_lower( two );
+        boost::algorithm::to_lower( three );
+        boost::algorithm::to_lower( four );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+template<typename String>
+void test_from_hex_failure ( const typename String::value_type ** tests ) {
+    int num_catches;
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, one;
+        arg.assign ( *p );
+        num_catches = 0;
+
+        try { boost::algorithm::unhex ( *p, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        BOOST_CHECK ( num_catches == 3 );
+        }
+    }
+
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    "2122234556ff",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_w [] = {
+    L"00101020",
+    L"2122234556FF3456",
+    L"2122234556ff3456",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex_fail [] = {
+    "2",
+    "H",
+    "234",
+    "21222G4556FF",
+    "h",
+    "21222g4556ff",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_fail_w [] = {
+    L"2",
+    L"12",
+    L"H",
+    L"234",
+    L"21222G4556FF",
+    L"h",
+    L"21222g4556ff",
+    NULL        // End of the list
+    };
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_to_hex<std::string> ( tohex );
+  test_to_hex_lower<std::string> ( tohex );
+  test_from_hex_success<std::string> ( fromhex );
+  test_from_hex_failure<std::string> ( fromhex_fail );
+
+  test_to_hex<std::wstring> ( tohex_w );
+  test_to_hex_lower<std::wstring> ( tohex_w );
+  test_from_hex_success<std::wstring> ( fromhex_w );
+  test_from_hex_failure<std::wstring> ( fromhex_fail_w );
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/hex_test2.cpp

@@ -0,0 +1,138 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+Test non-string cases; vector and list
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+void test_to_hex () {
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reverse
+        }
+    }
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+
+void test_from_hex_success () {
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reversed
+        }
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_to_hex ();
+  test_from_hex_success ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/hex_test3.cpp

@@ -0,0 +1,124 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+Try ostream_iterators
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+template <typename char_type>
+void test_to_hex ( const char_type ** tests ) {
+    typedef std::basic_string<char_type> String;
+    typedef std::basic_ostringstream<char_type> Stream;
+    typedef std::ostream_iterator<char_type, char_type> Iter;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+        String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, Iter ( one ));
+        boost::algorithm::hex ( arg, Iter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), Iter ( three ));
+        boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+        boost::algorithm::unhex ( argh.c_str (), Iter ( one ));
+        boost::algorithm::unhex ( argh, Iter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), Iter ( three ));
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+    }
+
+
+template <typename char_type>
+void test_from_hex_success ( const char_type ** tests ) {
+    typedef std::basic_string<char_type> String;
+    typedef std::basic_ostringstream<char_type> Stream;
+    typedef std::ostream_iterator<char_type, char_type> Iter;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+        String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p,                       Iter ( one ));
+        boost::algorithm::unhex ( arg,                      Iter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), Iter ( three ));
+        
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+
+        boost::algorithm::hex ( argh.c_str (),              Iter ( one ));
+        boost::algorithm::hex ( argh,                       Iter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), Iter ( three ));
+
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+
+    }
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+const wchar_t *fromhex_w [] = {
+    L"11223320",
+    L"21222345010256FF",
+    NULL        // End of the list
+    };
+
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_to_hex ( tohex );
+  test_to_hex ( tohex_w );
+  test_from_hex_success ( fromhex );
+  test_from_hex_success ( fromhex_w );
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/hex_test4.cpp

@@ -0,0 +1,146 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+Try ostream_iterators
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/exception/get_error_info.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <iostream>
+
+namespace ba = boost::algorithm;
+
+void test_short_input1 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const std::exception &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch std::exception in test_short_input1" );
+    BOOST_CHECK ( false );
+    }
+
+void test_short_input2 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::hex_decode_error &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::hex_decode_error in test_short_input2" );
+    BOOST_CHECK ( false );
+    }
+    
+void test_short_input3 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::not_enough_input in test_short_input3" );
+    BOOST_CHECK ( false );
+    }
+    
+//  Make sure that the right thing is thrown
+void test_short_input4 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+//  Make sure that the right thing is thrown
+void test_short_input5 () {
+    std::string s;
+    
+    try { ba::unhex ( "A", std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+
+void test_short_input () {
+//  BOOST_TEST_MESSAGE ( "Short input tests for boost::algorithm::unhex" );
+    test_short_input1 ();
+    test_short_input2 ();
+    test_short_input3 ();
+    test_short_input4 ();
+    test_short_input5 ();
+    }
+
+
+void test_nonhex_input1 () {
+    std::string s;
+    
+    try { ba::unhex ( "01234FG1234", std::back_inserter(s)); }
+    catch ( const std::exception &ex ) {
+        BOOST_CHECK ( 'G' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch std::exception in test_nonhex_input1" );
+    BOOST_CHECK ( false );
+    }
+
+void test_nonhex_input2 () {
+    std::string s;
+    
+    try { ba::unhex ( "012Z4FA1234", std::back_inserter(s)); }
+    catch ( const ba::hex_decode_error &ex ) {
+        BOOST_CHECK ( 'Z' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::hex_decode_error in test_nonhex_input2" );
+    BOOST_CHECK ( false );
+    }
+    
+void test_nonhex_input3 () {
+    std::string s;
+    
+    try { ba::unhex ( "01234FA12Q4", std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) {
+        BOOST_CHECK ( 'Q' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::non_hex_input in test_nonhex_input3" );
+    BOOST_CHECK ( false );
+    }
+    
+//  Make sure that the right thing is thrown
+void test_nonhex_input4 () {
+    std::string s;
+    
+    try { ba::unhex ( "P1234FA1234", std::back_inserter(s)); }
+    catch ( const ba::not_enough_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::non_hex_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+void test_nonhex_input () {
+//  BOOST_TEST_MESSAGE ( "Non hex input tests for boost::algorithm::unhex" );
+    test_nonhex_input1 ();
+    test_nonhex_input2 ();
+    test_nonhex_input3 ();
+    test_nonhex_input4 ();
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    test_short_input ();
+    test_nonhex_input ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/inclusive_scan_test.cpp

@@ -0,0 +1,153 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+#include <numeric>
+#include <algorithm>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/iota.hpp>
+#include <boost/algorithm/cxx17/inclusive_scan.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+int triangle(int n) { return n*(n+1)/2; }
+
+void basic_tests_op()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == (int)(i+1) * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == triangle(i));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == triangle(i + 1));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<int>());
+    assert(res.empty());
+    }
+}
+
+void test_inclusive_scan_op()
+{
+	basic_tests_op();
+	BOOST_CHECK(true);
+}
+
+void basic_tests_init()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 50);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 50 + (int)(i+1) * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 40);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 40 + triangle(i));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 30);
+    for (size_t i = 0; i < v.size(); ++i)
+        assert(v[i] == 30 + triangle(i + 1));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<int>(), 40);
+    assert(res.empty());
+    }
+}
+
+
+void test_inclusive_scan_init()
+{
+	basic_tests_init();
+	BOOST_CHECK(true);
+}
+
+void basic_tests_op_init()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 50);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 50 + (int)(i+1) * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 40);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 40 + triangle(i));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), 30);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 30 + triangle(i + 1));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<int>(), 40);
+    BOOST_CHECK(res.empty());
+    }
+}
+
+void test_inclusive_scan_op_init()
+{
+    basic_tests_op_init();
+	BOOST_CHECK(true);
+}
+
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_inclusive_scan_op();
+  test_inclusive_scan_init();
+  test_inclusive_scan_op_init();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/iota_test1.cpp

@@ -0,0 +1,114 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/iota.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+#include <list>
+
+//  Test to make sure a sequence is "correctly formed"; i.e, ascending by one
+template <typename Iterator, typename T>
+BOOST_CXX14_CONSTEXPR bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
+    if ( first == last ) return true;
+    if ( initial_value != *first ) return false;
+    Iterator prev = first;
+    while ( ++first != last ) {
+        if (( *first - *prev ) != 1 )
+            return false;
+        prev = first;
+        }
+    return true;
+    }
+
+    
+template <typename Range, typename T>
+BOOST_CXX14_CONSTEXPR bool test_iota_results ( const Range &r, T initial_value ) {
+    return test_iota_results (boost::begin (r), boost::end (r), initial_value );
+}
+
+    
+void test_ints () {
+    std::vector<int> v;
+    std::list<int> l;
+
+    v.clear (); v.resize ( 10 );
+    boost::algorithm::iota ( v.begin (), v.end (), 23 );
+    BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
+    
+    v.clear (); v.resize ( 19 );
+    boost::algorithm::iota ( v, 18 );
+    BOOST_CHECK ( test_iota_results ( v, 18 ));
+    
+    v.clear ();
+    boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
+    BOOST_CHECK ( test_iota_results ( v, 99 ));
+    
+    v.clear ();
+    boost::algorithm::iota_n ( std::back_inserter(v), 99, 0 );
+    BOOST_CHECK ( v.size() == 0 );
+
+/*
+    l.clear (); l.reserve ( 5 );
+    boost::algorithm::iota ( l.begin (), l.end (), 123 );
+    BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
+    
+    l.clear (); l.reserve ( 9 );
+    boost::algorithm::iota ( l.begin (), l.end (), 87 );
+    BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
+*/
+
+    l.clear ();
+    boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
+    BOOST_CHECK ( test_iota_results ( l, 99 ));
+    
+    l.clear ();
+    boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
+    BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
+    }
+    
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr_iota() {
+    bool res = true;
+    int data[] = {0, 0, 0};
+    boost::algorithm::iota(data, data, 1); // fill none
+    res = (res && data[0] == 0);
+    
+    boost::algorithm::iota(data, data + 3, 1); // fill all
+    res = (res && test_iota_results(data, data + 3, 1));
+    
+    return res;
+    }
+    
+    
+BOOST_CXX14_CONSTEXPR inline bool test_constexpr_iota_n() {
+    bool res = true;
+    int data[] = {0, 0, 0};
+    boost::algorithm::iota_n(data, 1, 0); // fill none
+    res = (res && data[0] == 0);
+    
+    boost::algorithm::iota_n(data, 1, 3); // fill all
+    res = (res && test_iota_results(data, 1));
+    
+    return res;
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_ints ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_iota_res = test_constexpr_iota ();
+  BOOST_CHECK(constexpr_iota_res);
+  BOOST_CXX14_CONSTEXPR bool constexpr_iota_n_res = test_constexpr_iota_n ();
+  BOOST_CHECK(constexpr_iota_n_res);
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/is_palindrome_test.cpp

@@ -0,0 +1,76 @@
+/*
+  Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2016
+
+  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)
+
+  See http://www.boost.org/ for latest version.
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/is_palindrome.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <algorithm>
+#include <iostream>
+#include <list>
+#include <vector>
+
+
+namespace ba = boost::algorithm;
+
+
+template <typename T>
+bool funcComparator(const T& v1, const T& v2)
+{
+    return v1 == v2;
+}
+
+struct functorComparator
+{
+    template <typename T>
+    bool operator()(const T& v1, const T& v2) const
+    {
+        return v1 == v2;
+    }
+};
+
+void test_is_palindrome()
+{
+    const std::list<int> empty;
+    const std::vector<char> singleElement(1, 'z');
+    int oddNonPalindrome[] = {3,2,2};
+    const int oddPalindrome[] = {1,2,3,2,1};
+    const int evenPalindrome[] = {1,2,2,1};
+    int evenNonPalindrome[] = {1,4,8,8};
+    const char* stringNullPtr = NULL;
+
+    // Test a default operator==
+    BOOST_CHECK ( ba::is_palindrome(empty));
+    BOOST_CHECK ( ba::is_palindrome(singleElement));
+    BOOST_CHECK (!ba::is_palindrome(boost::begin(oddNonPalindrome),  boost::end(oddNonPalindrome)));
+    BOOST_CHECK ( ba::is_palindrome(boost::begin(oddPalindrome),     boost::end(oddPalindrome)));
+    BOOST_CHECK ( ba::is_palindrome(boost::begin(evenPalindrome),    boost::end(evenPalindrome)));
+    BOOST_CHECK (!ba::is_palindrome(boost::begin(evenNonPalindrome), boost::end(evenNonPalindrome)));
+
+    //Test the custom comparators
+    BOOST_CHECK ( ba::is_palindrome(empty.begin(), empty.end(), functorComparator()));
+    BOOST_CHECK (!ba::is_palindrome(boost::begin(oddNonPalindrome), boost::end(oddNonPalindrome), funcComparator<int>));
+    BOOST_CHECK ( ba::is_palindrome(evenPalindrome, std::equal_to<int>()));
+    
+    //Test C-strings like cases
+    BOOST_CHECK ( ba::is_palindrome(stringNullPtr));
+    BOOST_CHECK ( ba::is_palindrome(""));
+    BOOST_CHECK ( ba::is_palindrome("a"));
+    BOOST_CHECK ( ba::is_palindrome("abacaba", std::equal_to<char>()));
+    BOOST_CHECK ( ba::is_palindrome("abba"));
+    BOOST_CHECK (!ba::is_palindrome("acab"));
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_is_palindrome ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/is_partitioned_test1.cpp

@@ -0,0 +1,77 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/is_partitioned.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+template <typename T>
+struct less_than {
+public:
+    BOOST_CXX14_CONSTEXPR less_than ( T foo ) : val ( foo ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    BOOST_CXX14_CONSTEXPR bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+    };
+
+    
+BOOST_CXX14_CONSTEXPR bool test_constexpr() {
+    int v[] = { 4, 5, 6, 7, 8, 9, 10 };
+    bool res = true;
+    res = ( res && ba::is_partitioned ( v, less_than<int>(3)));  // no elements
+    res = ( res && ba::is_partitioned ( v, less_than<int>(5)));  // only the first element
+    res = ( res && ba::is_partitioned ( v, less_than<int>(8)));  // in the middle somewhere
+    res = ( res && ba::is_partitioned ( v, less_than<int>(99))); // all elements
+    return res;
+    }
+    
+
+void test_sequence1 () {
+    std::vector<int> v;
+    
+    v.clear ();
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3)));      // no elements
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6)));      // only the first element
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy 
+
+//  With bidirectional iterators.
+    std::list<int> l;
+    for ( int i = 5; i < 15; ++i )
+        l.push_back ( i );
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3)));       // no elements
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6)));       // only the first element
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10)));  // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99)));      // all elements satisfy 
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr ();
+  BOOST_CHECK ( constexpr_res );
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/is_partitioned_until_test.cpp

@@ -0,0 +1,63 @@
+/*
+   Copyright (c) Marshall Clow 2011-2012, Alexander Zaitsev <zamazan4ik@gmail.com>, 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/is_partitioned_until.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+template <typename T>
+struct less_than {
+public:
+    less_than ( T foo ) : val ( foo ) {}
+    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+};
+
+
+void test_sequence1 () {
+    std::vector<int> v;
+
+    v.clear ();
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    BOOST_CHECK ( ba::is_partitioned_until ( v, less_than<int>(3)) == v.end());      // no elements
+    BOOST_CHECK ( ba::is_partitioned_until ( v, less_than<int>(6)) == v.end());      // only the first element
+    BOOST_CHECK ( ba::is_partitioned_until ( v, less_than<int>(10)) == v.end()); // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned_until ( v, less_than<int>(99)) == v.end()); // all elements satisfy
+//  With bidirectional iterators.
+    std::list<int> l;
+    for ( int i = 5; i < 15; ++i )
+        l.push_back ( i );
+    BOOST_CHECK ( ba::is_partitioned_until ( l.begin (), l.end (), less_than<int>(3)) == l.end());       // no elements
+    BOOST_CHECK ( ba::is_partitioned_until ( l.begin (), l.end (), less_than<int>(6)) == l.end());       // only the first element
+    BOOST_CHECK ( ba::is_partitioned_until ( l.begin (), l.end (), less_than<int>(10)) == l.end());  // in the middle somewhere
+    BOOST_CHECK ( ba::is_partitioned_until ( l.begin (), l.end (), less_than<int>(99)) == l.end());      // all elements satisfy
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/is_permutation_test1.cpp

@@ -0,0 +1,136 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/is_permutation.hpp>
+#include <boost/algorithm/cxx14/is_permutation.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+#include "iterator_test.hpp"
+
+template <typename T>
+bool eq ( const T& a, const T& b ) { return a == b; }
+
+template <typename T>
+bool never_eq ( const T&, const T& ) { return false; }
+
+namespace ba = boost::algorithm;
+
+void test_sequence1 () {
+    int num[] = { 1, 1, 2, 3, 5 };
+    const int sz = sizeof (num)/sizeof(num[0]);
+
+//  Empty sequences
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num), 
+            forward_iterator<int *>(num)));
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num), 
+            forward_iterator<int *>(num),     forward_iterator<int *>(num)));
+    BOOST_CHECK (
+        ba::is_permutation (
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num)));
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num), 
+            forward_iterator<int *>(num), 
+            never_eq<int> ));       // Since the sequences are empty, the pred is never called
+            
+//  Empty vs. non-empty
+    BOOST_CHECK ( !
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num), 
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + 1)));
+
+    BOOST_CHECK ( !
+        ba::is_permutation ( 
+            forward_iterator<int *>(num + 1), forward_iterator<int *>(num + 2), 
+            forward_iterator<int *>(num),     forward_iterator<int *>(num)));
+                    
+    BOOST_CHECK ( !
+        ba::is_permutation (
+            random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + 2), 
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num)));
+
+    BOOST_CHECK ( !
+        ba::is_permutation (
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num), 
+            random_access_iterator<int *>(num + 1), random_access_iterator<int *>(num + 2)));
+
+//  Something should be a permutation of itself
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz), 
+            forward_iterator<int *>(num)));
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz), 
+            forward_iterator<int *>(num), eq<int> ));
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz), 
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz )));
+    BOOST_CHECK (
+        ba::is_permutation (
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz), 
+            forward_iterator<int *>(num),     forward_iterator<int *>(num + sz ),
+            eq<int> ));
+            
+    BOOST_CHECK (
+        ba::is_permutation (
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz), 
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz)));
+    BOOST_CHECK (
+        ba::is_permutation (
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz), 
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz),
+            eq<int> ));
+    BOOST_CHECK (
+        ba::is_permutation (
+            random_access_iterator<int *>(num),     random_access_iterator<int *>(num + sz), 
+            forward_iterator<int *>(num),           forward_iterator<int *>(num + sz),
+            eq<int> ));
+    
+
+    std::vector<int> v, v1;
+    
+    v.clear ();
+    for ( std::size_t i = 5; i < 15; ++i )
+        v.push_back ( i );
+    v1 = v;
+    BOOST_CHECK ( ba::is_permutation ( v.begin (), v.end (), v.begin ()));  // better be a permutation of itself!
+    BOOST_CHECK ( ba::is_permutation ( v.begin (), v.end (), v1.begin ()));    
+
+//  With bidirectional iterators.
+    std::list<int> l;
+    std::copy ( v.begin (), v.end (), std::back_inserter ( l ));
+    BOOST_CHECK ( ba::is_permutation ( l.begin (), l.end (), l.begin ()));  // better be a permutation of itself!
+    BOOST_CHECK ( ba::is_permutation ( l.begin (), l.end (), v1.begin ()));
+    for ( std::size_t i = 0; i < l.size (); ++i ) {
+        l.push_back ( *l.begin ()); l.pop_front (); // rotation
+        BOOST_CHECK ( ba::is_permutation ( l.begin (), l.end (), v1.begin ()));
+        }   
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/iterator_test.hpp

@@ -0,0 +1,305 @@
+/* 
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#ifndef ITERATOR_TEST_H
+#define ITERATOR_TEST_H
+
+/* 
+    A set of iterator adapters for constructing test cases
+    From an iterator (or a pointer), you can make any class of iterator.
+    Assuming you want to degrade the capabilities.
+    
+    Modeled closely on work that Howard Hinnant did for libc++.
+*/
+
+#include <iterator>
+
+// == Input Iterator ==
+template <typename It>
+class input_iterator {
+public:
+    typedef          std::input_iterator_tag                   iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
+
+    BOOST_CXX14_CONSTEXPR input_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit input_iterator(It it) : it_(it) {}
+
+    template <typename U>
+    BOOST_CXX14_CONSTEXPR input_iterator(const input_iterator<U>& u) :it_(u.it_) {}
+
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
+
+    BOOST_CXX14_CONSTEXPR input_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR input_iterator  operator++(int) {input_iterator tmp(*this); ++(*this); return tmp;}
+
+    BOOST_CXX14_CONSTEXPR friend bool operator==(const input_iterator& x, const input_iterator& y)
+        {return x.it_ == y.it_;}
+    BOOST_CXX14_CONSTEXPR friend bool operator!=(const input_iterator& x, const input_iterator& y)
+        {return !(x == y);}
+
+private:
+    It it_;
+    template <typename U> friend class input_iterator;
+};
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator==(const input_iterator<T>& x, const input_iterator<U>& y)
+{
+    return x.base() == y.base();
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator!=(const input_iterator<T>& x, const input_iterator<U>& y)
+{
+    return !(x == y);
+}
+
+
+// == Forward Iterator ==
+template <typename It>
+class forward_iterator {
+public:
+    typedef          std::forward_iterator_tag                 iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
+
+    BOOST_CXX14_CONSTEXPR forward_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit forward_iterator(It it) : it_(it) {}
+    template <typename U>
+    BOOST_CXX14_CONSTEXPR forward_iterator(const forward_iterator<U>& u) :it_(u.it_) {}
+
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
+
+    BOOST_CXX14_CONSTEXPR forward_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR forward_iterator  operator++(int) {forward_iterator tmp(*this); ++(*this); return tmp;}
+
+    BOOST_CXX14_CONSTEXPR friend bool operator==(const forward_iterator& x, const forward_iterator& y)
+        {return x.it_ == y.it_;}
+    BOOST_CXX14_CONSTEXPR friend bool operator!=(const forward_iterator& x, const forward_iterator& y)
+        {return !(x == y);}
+private:
+    It it_;
+
+    template <typename U> friend class forward_iterator;
+};
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator==(const forward_iterator<T>& x, const forward_iterator<U>& y)
+{
+    return x.base() == y.base();
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator!=(const forward_iterator<T>& x, const forward_iterator<U>& y)
+{
+    return !(x == y);
+}
+
+// == Bidirectional Iterator ==
+template <typename It>
+class bidirectional_iterator
+{
+public:
+    typedef          std::bidirectional_iterator_tag           iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
+
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit bidirectional_iterator(It it) : it_(it) {}
+    template <typename U>
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator(const bidirectional_iterator<U>& u) :it_(u.it_) {}
+
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
+
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator  operator++(int) {bidirectional_iterator tmp(*this); ++(*this); return tmp;}
+
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator& operator--()    {--it_; return *this;}
+    BOOST_CXX14_CONSTEXPR bidirectional_iterator  operator--(int) {bidirectional_iterator tmp(*this); --(*this); return tmp;}
+private:
+    It it_;
+    template <typename U> friend class bidirectional_iterator;
+};
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator==(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
+{
+    return x.base() == y.base();
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator!=(const bidirectional_iterator<T>& x, const bidirectional_iterator<U>& y)
+{
+    return !(x == y);
+}
+
+
+// == Random Access Iterator ==
+template <typename It>
+class random_access_iterator {
+public:
+    typedef          std::random_access_iterator_tag           iterator_category;
+    typedef typename std::iterator_traits<It>::value_type      value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
+
+    BOOST_CXX14_CONSTEXPR random_access_iterator() : it_() {}
+    BOOST_CXX14_CONSTEXPR explicit random_access_iterator(It it) : it_(it) {}
+    template <typename U>
+    BOOST_CXX14_CONSTEXPR random_access_iterator(const random_access_iterator<U>& u) :it_(u.it_) {}
+
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+    BOOST_CXX14_CONSTEXPR pointer  operator->() const {return  it_;}
+
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator++(int) {random_access_iterator tmp(*this); ++(*this); return tmp;}
+
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator--()    {--it_; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator--(int) {random_access_iterator tmp(*this); --(*this); return tmp;}
+
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator+=(difference_type n)       {it_ += n; return *this;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator+ (difference_type n) const {random_access_iterator tmp(*this); tmp += n; return tmp;}
+    BOOST_CXX14_CONSTEXPR friend random_access_iterator operator+(difference_type n, random_access_iterator x) {x += n; return x;}
+
+    BOOST_CXX14_CONSTEXPR random_access_iterator& operator-=(difference_type n)       {return *this += -n;}
+    BOOST_CXX14_CONSTEXPR random_access_iterator  operator- (difference_type n) const {random_access_iterator tmp(*this); tmp -= n; return tmp;}
+
+    BOOST_CXX14_CONSTEXPR reference operator[](difference_type n) const {return it_[n];}
+private:
+    It it_;
+
+    template <typename U> friend class random_access_iterator;
+};
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator==(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return x.base() == y.base();
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator!=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return !(x == y);
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator<(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return x.base() < y.base();
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator<=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return !(y < x);
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator>(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return y < x;
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline bool
+operator>=(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return !(x < y);
+}
+
+template <typename T, typename U>
+BOOST_CXX14_CONSTEXPR inline typename std::iterator_traits<T>::difference_type
+operator-(const random_access_iterator<T>& x, const random_access_iterator<U>& y)
+{
+    return x.base() - y.base();
+}
+
+
+// == Output Iterator ==
+template <typename It>
+class output_iterator {
+public:
+    typedef          std::output_iterator_tag                  iterator_category;
+    typedef void                                               value_type;
+    typedef typename std::iterator_traits<It>::difference_type difference_type;
+    typedef It                                                 pointer;
+    typedef typename std::iterator_traits<It>::reference       reference;
+
+    BOOST_CXX14_CONSTEXPR It base() const {return it_;}
+
+    BOOST_CXX14_CONSTEXPR output_iterator () {}
+    BOOST_CXX14_CONSTEXPR explicit output_iterator(It it) : it_(it) {}
+
+    template <typename U>
+    BOOST_CXX14_CONSTEXPR output_iterator(const output_iterator<U>& u) :it_(u.it_) {}
+
+    BOOST_CXX14_CONSTEXPR reference operator*() const {return *it_;}
+
+    BOOST_CXX14_CONSTEXPR output_iterator& operator++()    {++it_; return *this;}
+    BOOST_CXX14_CONSTEXPR output_iterator  operator++(int) {output_iterator tmp(*this); ++(*this); return tmp;}
+
+private:
+    It it_;
+    template <typename U> friend class output_iterator;
+    };
+    
+//  No comparison operators for output iterators
+    
+
+// == Get the base of an iterator; used for comparisons ==
+template <typename Iter>
+BOOST_CXX14_CONSTEXPR inline Iter base(output_iterator<Iter> i) { return i.base(); }
+
+template <typename Iter>
+BOOST_CXX14_CONSTEXPR inline Iter base(input_iterator<Iter> i) { return i.base(); }
+
+template <typename Iter>
+BOOST_CXX14_CONSTEXPR inline Iter base(forward_iterator<Iter> i) { return i.base(); }
+
+template <typename Iter>
+BOOST_CXX14_CONSTEXPR inline Iter base(bidirectional_iterator<Iter> i) { return i.base(); }
+
+template <typename Iter>
+BOOST_CXX14_CONSTEXPR inline Iter base(random_access_iterator<Iter> i) { return i.base(); }
+
+template <typename Iter>    // everything else
+BOOST_CXX14_CONSTEXPR inline Iter base(Iter i) { return i; }
+
+#endif  // ITERATORS_H

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/mismatch_test.cpp

@@ -0,0 +1,195 @@
+/* 
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx14/mismatch.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+template <typename T>
+BOOST_CXX14_CONSTEXPR bool eq ( const T& a, const T& b ) { return a == b; }
+
+template <typename T>
+BOOST_CXX14_CONSTEXPR bool never_eq ( const T&, const T& ) { return false; }
+
+namespace ba = boost::algorithm;
+
+template <typename Iter1, typename Iter2>
+BOOST_CXX14_CONSTEXPR bool iter_eq ( std::pair<Iter1, Iter2> pr, Iter1 first, Iter2 second ) {
+    return pr.first == first && pr.second == second;
+    }
+
+void test_mismatch ()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    BOOST_CXX14_CONSTEXPR int num[] = { 1, 1, 2, 3, 5 };
+    const int sz = sizeof (num)/sizeof(num[0]);
+    
+    
+//  No mismatch for empty sequences
+    BOOST_CHECK ( iter_eq ( 
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num), input_iterator<const int *>(num)));
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num),
+                       never_eq<int> ),
+                input_iterator<const int *>(num), input_iterator<const int *>(num)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num), 
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num),
+                       never_eq<int> ),
+                random_access_iterator<const int *>(num), random_access_iterator<const int *>(num)));
+                              
+//  Empty vs. non-empty mismatch immediately
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num),     input_iterator<const int *>(num)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num)));
+                    
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num + 2), 
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num)),
+                random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num)));
+
+//  Single element sequences are equal if they contain the same value
+    BOOST_CHECK ( iter_eq ( 
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1)));
+                       
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       eq<int> ),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1)));
+                    
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       eq<int> ),
+                random_access_iterator<const int *>(num + 1), random_access_iterator<const int *>(num + 1)));
+
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       never_eq<int> ),
+               input_iterator<const int *>(num),     input_iterator<const int *>(num)));
+               
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + 1),
+                       never_eq<int> ),
+               random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)),
+               input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2),
+                       eq<int> ),
+               input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 2)));
+
+    BOOST_CHECK ( iter_eq (
+            ba::mismatch ( input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 3), 
+                           input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                           input_iterator<const int *>(num + 2), input_iterator<const int *>(num)));
+                           
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 3),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       eq<int> ),
+               input_iterator<const int *>(num + 2), input_iterator<const int *>(num)));
+                       
+                              
+                              
+//  Identical long sequences are equal. 
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz)),
+            input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       eq<int> ),
+            input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       never_eq<int> ),
+            input_iterator<const int *>(num),     input_iterator<const int *>(num)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),             input_iterator<const int *>(num + sz),
+                       random_access_iterator<const int *>(num),     random_access_iterator<const int *>(num + sz),
+                       never_eq<int> ),
+            input_iterator<const int *>(num),     random_access_iterator<const int *>(num)));
+
+//  Different sequences are different
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz)),
+            input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 1)));
+
+    BOOST_CHECK ( iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num + 1), input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       eq<int> ),
+            input_iterator<const int *>(num + 2), input_iterator<const int *>(num + 1)));
+            
+//  Checks constexpr
+    BOOST_CXX14_CONSTEXPR bool res = (
+//  No mismatch for empty
+        iter_eq ( 
+            ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                           input_iterator<const int *>(num),     input_iterator<const int *>(num)),
+                input_iterator<const int *>(num), input_iterator<const int *>(num))
+//  Empty vs. non-empty mismatch immediately  
+        && iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num), 
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1)),
+                input_iterator<const int *>(num),     input_iterator<const int *>(num))
+//  Single element sequences are equal if they contain the same value                
+        && iter_eq ( 
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + 1),
+                       eq<int>),
+                input_iterator<const int *>(num + 1), input_iterator<const int *>(num + 1))
+//  Identical long sequences are equal.
+        && iter_eq (
+        ba::mismatch ( input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       input_iterator<const int *>(num),     input_iterator<const int *>(num + sz),
+                       eq<int> ),
+                input_iterator<const int *>(num + sz), input_iterator<const int *>(num + sz))
+        );
+    
+    BOOST_CHECK ( res );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_mismatch ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/none_of_test.cpp

@@ -0,0 +1,105 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/none_of.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <functional>
+#include <vector>
+#include <list>
+
+template<typename T>
+struct is_ {
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
+private:
+    is_ (); // need a value
+
+    T val_;
+    };
+
+namespace ba = boost::algorithm;
+
+void test_none()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 5, 0, 18, 1 };
+    std::vector<int> vi(some_numbers, some_numbers + 5);
+    std::list<int>   li(vi.begin(), vi.end ());
+    
+    int some_letters[] = { 'a', 'q', 'n', 'y', 'n' };
+    std::vector<char> vc(some_letters, some_letters + 5);
+    
+    BOOST_CHECK ( ba::none_of_equal ( vi,                                  100 ));
+    BOOST_CHECK ( ba::none_of       ( vi,                       is_<int> ( 100 )));
+    BOOST_CHECK ( ba::none_of_equal ( vi.begin(),     vi.end(),            100 ));
+    BOOST_CHECK ( ba::none_of       ( vi.begin(),     vi.end(), is_<int> ( 100 )));
+
+    BOOST_CHECK (!ba::none_of_equal ( vi,                                    1 ));
+    BOOST_CHECK (!ba::none_of       ( vi,                       is_<int> (   1 )));
+    BOOST_CHECK (!ba::none_of_equal ( vi.begin(),     vi.end(),              1 ));
+    BOOST_CHECK (!ba::none_of       ( vi.begin(),     vi.end(), is_<int> (   1 )));
+
+    BOOST_CHECK ( ba::none_of_equal ( vi.end(),       vi.end(),              0 ));
+    BOOST_CHECK ( ba::none_of       ( vi.end(),       vi.end(), is_<int> (   0 )));
+
+//   5 is not in { 0, 18, 1 }, but 1 is
+    BOOST_CHECK ( ba::none_of_equal ( vi.begin() + 2, vi.end(),              5 ));
+    BOOST_CHECK ( ba::none_of       ( vi.begin() + 2, vi.end(), is_<int> (   5 )));
+    BOOST_CHECK (!ba::none_of_equal ( vi.begin() + 2, vi.end(),              1 ));
+    BOOST_CHECK (!ba::none_of       ( vi.begin() + 2, vi.end(), is_<int> (   1 )));
+
+//  18 is not in { 1, 5, 0 }, but 5 is
+    BOOST_CHECK ( ba::none_of_equal ( vi.begin(),     vi.begin() + 3,            18 ));
+    BOOST_CHECK ( ba::none_of       ( vi.begin(),     vi.begin() + 3, is_<int> ( 18 )));
+    BOOST_CHECK (!ba::none_of_equal ( vi.begin(),     vi.begin() + 3,             5 ));
+    BOOST_CHECK (!ba::none_of       ( vi.begin(),     vi.begin() + 3, is_<int> (  5 )));
+    
+    BOOST_CHECK ( ba::none_of_equal ( vc,             'z' ));
+    BOOST_CHECK ( ba::none_of       ( vc, is_<char> ( 'z' )));
+
+    BOOST_CHECK (!ba::none_of_equal ( vc,             'a' ));
+    BOOST_CHECK (!ba::none_of       ( vc, is_<char> ( 'a' )));
+
+    BOOST_CHECK (!ba::none_of_equal ( vc,             'n' ));
+    BOOST_CHECK (!ba::none_of       ( vc, is_<char> ( 'n' )));
+
+    BOOST_CHECK ( ba::none_of_equal ( vi.begin(), vi.begin(),   1 ));
+    BOOST_CHECK ( ba::none_of_equal ( vc.begin(), vc.begin(), 'a' ));
+    BOOST_CHECK ( ba::none_of       ( vi.begin(), vi.begin(), is_<int>  (   1 )));
+    BOOST_CHECK ( ba::none_of       ( vc.begin(), vc.begin(), is_<char> ( 'a' )));
+
+    BOOST_CHECK ( ba::none_of_equal ( li,                                  100 ));
+    BOOST_CHECK ( ba::none_of       ( li,                       is_<int> ( 100 )));
+    BOOST_CHECK ( ba::none_of_equal ( li.begin(),     li.end(),            100 ));
+    BOOST_CHECK ( ba::none_of       ( li.begin(),     li.end(), is_<int> ( 100 )));
+    
+    std::list<int>::iterator l_iter = li.begin ();
+    l_iter++; l_iter++; l_iter++;
+    BOOST_CHECK ( ba::none_of_equal ( li.begin(), l_iter,            18 ));
+    BOOST_CHECK ( ba::none_of       ( li.begin(), l_iter, is_<int> ( 18 )));
+    BOOST_CHECK (!ba::none_of       ( li.begin(), l_iter, is_<int> (  5 )));
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+        !ba::none_of_equal ( some_numbers, 1 )                                 &&
+        !ba::none_of       ( some_numbers, is_<int> ( 1 ))                     &&
+         ba::none_of_equal ( some_numbers, some_numbers + 3,            100 )  &&
+         ba::none_of       ( some_numbers, some_numbers + 3, is_<int> ( 100 )) &&
+        true;
+
+    BOOST_CHECK ( constexpr_res );
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_none();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/one_of_test.cpp

@@ -0,0 +1,107 @@
+/* 
+   Copyright (c) Marshall Clow 2008-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/one_of.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <functional>
+#include <vector>
+#include <list>
+
+template<typename T>
+struct is_ {
+    BOOST_CXX14_CONSTEXPR is_ ( T v ) : val_ ( v ) {}
+    BOOST_CXX14_CONSTEXPR bool operator () ( T comp ) const { return val_ == comp; }
+private:
+    is_ (); // need a value
+
+    T val_;
+    };
+
+namespace ba = boost::algorithm;
+
+void test_one ()
+{
+//  Note: The literal values here are tested against directly, careful if you change them:
+    BOOST_CXX14_CONSTEXPR int some_numbers[] = { 1, 1, 2, 3, 5 };
+    std::vector<int> vi(some_numbers, some_numbers + 5);
+    std::list<int>   li(vi.begin(), vi.end ());
+    
+    int some_letters[] = { 'a', 'q', 'n', 'y', 'n' };
+    std::vector<char> vc(some_letters, some_letters + 5);
+    
+    BOOST_CHECK (!ba::one_of_equal ( vi,                                  1 ));
+    BOOST_CHECK (!ba::one_of       ( vi,                       is_<int> ( 1 )));
+    BOOST_CHECK (!ba::one_of_equal ( vi.begin(),     vi.end(),            1 ));
+    BOOST_CHECK (!ba::one_of       ( vi.begin(),     vi.end(), is_<int> ( 1 )));
+
+    BOOST_CHECK (!ba::one_of_equal ( vi,                                  0 ));
+    BOOST_CHECK (!ba::one_of       ( vi,                       is_<int> ( 0 )));
+    BOOST_CHECK (!ba::one_of_equal ( vi.begin(),     vi.end(),            0 ));
+    BOOST_CHECK (!ba::one_of       ( vi.begin(),     vi.end(), is_<int> ( 0 )));
+    
+    BOOST_CHECK ( ba::one_of_equal ( vi,                                  2 ));
+    BOOST_CHECK ( ba::one_of       ( vi,                       is_<int> ( 2 )));
+    BOOST_CHECK ( ba::one_of_equal ( vi.begin(),     vi.end(),            2 ));
+    BOOST_CHECK ( ba::one_of       ( vi.begin(),     vi.end(), is_<int> ( 2 )));
+
+//  Check for a match at the end
+    BOOST_CHECK ( ba::one_of_equal ( vi,                                  5 ));
+    BOOST_CHECK ( ba::one_of       ( vi,                       is_<int> ( 5 )));
+    BOOST_CHECK ( ba::one_of_equal ( vi.begin(),     vi.end(),            5 ));
+    BOOST_CHECK ( ba::one_of       ( vi.begin(),     vi.end(), is_<int> ( 5 )));
+
+    BOOST_CHECK ( ba::one_of_equal ( vi.begin() + 1, vi.end(),            1 ));
+    BOOST_CHECK ( ba::one_of       ( vi.begin() + 1, vi.end(), is_<int> ( 1 )));
+    
+    BOOST_CHECK ( ba::one_of_equal ( vc.begin() + 1, vc.begin() + 2,             'q' ));
+    BOOST_CHECK ( ba::one_of       ( vc.begin() + 1, vc.begin() + 2, is_<char> ( 'q' )));
+
+    BOOST_CHECK (!ba::one_of_equal ( vc, '!' ));
+    BOOST_CHECK (!ba::one_of       ( vc, is_<char> ( '!' )));
+    
+    BOOST_CHECK (!ba::one_of_equal ( vc, 'n' ));
+    BOOST_CHECK (!ba::one_of       ( vc, is_<char> ( 'n' )));
+
+//  Empty range check
+    BOOST_CHECK (!ba::one_of_equal ( vi.begin(), vi.begin(),   1 ));
+    BOOST_CHECK (!ba::one_of_equal ( vc.begin(), vc.begin(), 'a' ));
+    BOOST_CHECK (!ba::one_of       ( vi.begin(), vi.begin(), is_<int>  (   1 )));
+    BOOST_CHECK (!ba::one_of       ( vc.begin(), vc.begin(), is_<char> ( 'a' )));
+    
+    BOOST_CHECK (!ba::one_of_equal ( li,                                  1 ));
+    BOOST_CHECK (!ba::one_of       ( li,                       is_<int> ( 1 )));
+    BOOST_CHECK (!ba::one_of_equal ( li.begin(),     li.end(),            1 ));
+    BOOST_CHECK (!ba::one_of       ( li.begin(),     li.end(), is_<int> ( 1 )));
+    
+    std::list<int>::iterator l_iter = li.begin ();
+    l_iter++; l_iter++; l_iter++;
+    BOOST_CHECK (!ba::one_of_equal ( li.begin(), l_iter,            1 ));
+    BOOST_CHECK (!ba::one_of       ( li.begin(), l_iter, is_<int> ( 1 )));
+    BOOST_CHECK ( ba::one_of_equal ( li.begin(), l_iter,            2 ));
+    BOOST_CHECK ( ba::one_of       ( li.begin(), l_iter, is_<int> ( 2 )));
+    BOOST_CHECK (!ba::one_of_equal ( li.begin(), l_iter,            3 ));
+    BOOST_CHECK (!ba::one_of       ( li.begin(), l_iter, is_<int> ( 3 )));
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res =
+       !ba::one_of ( some_numbers, is_<int> ( 6 ))                       &&
+        ba::one_of ( some_numbers + 1, some_numbers + 3, is_<int> ( 1 )) &&
+       true;
+
+    BOOST_CHECK ( constexpr_res );
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_one ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/ordered_test.cpp

@@ -0,0 +1,174 @@
+//  Copyright (c) 2010 Nuovation System Designs, LLC
+//    Grant Erickson <gerickson@nuovations.com>
+//
+//  Reworked by Marshall Clow; August 2010
+//
+//  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)
+//
+//  See http://www.boost.org/ for latest version.
+
+#include <algorithm>
+#include <iostream>
+
+#include <boost/algorithm/cxx11/is_sorted.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+using namespace boost;
+
+/* Preprocessor Defines */
+
+#define elementsof(v)   (sizeof (v) / sizeof (v[0]))
+#define a_begin(v)      (&v[0])
+#define a_end(v)        (v + elementsof (v))
+#define a_range(v)      v
+#define b_e(v)          a_begin(v),a_end(v)
+
+namespace ba = boost::algorithm;
+
+BOOST_CXX14_CONSTEXPR bool less( int x, int y ) { return x < y; }
+
+static void
+test_ordered(void)
+{
+    BOOST_CXX14_CONSTEXPR const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
+    BOOST_CXX14_CONSTEXPR const int randomValues[] = { 3, 6, 1, 2, 7 };
+    const int constantValues[] = { 1, 2, 2, 2, 5 };
+          int nonConstantArray[] = { 1, 2, 2, 2, 5 };
+    const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
+
+//  Begin/end checks
+    BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
+    BOOST_CHECK (  ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
+    BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
+
+//  Range checks
+    BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
+    BOOST_CHECK (  ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
+    BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
+
+    BOOST_CHECK (  ba::is_sorted_until ( b_e(strictlyIncreasingValues))                       ==      a_end(strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_sorted_until ( b_e(strictlyIncreasingValues),     std::less<int>()) ==      a_end(strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_sorted_until ( a_range(strictlyIncreasingValues))                   == boost::end(strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_sorted_until ( a_range(strictlyIncreasingValues), std::less<int>()) == boost::end(strictlyIncreasingValues));
+
+//  Check for const and non-const arrays
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(constantValues),       std::less<int>()) ==      a_end(constantValues));
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(constantValues),   std::less<int>()) == boost::end(constantValues));
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(nonConstantArray),     std::less<int>()) ==      a_end(nonConstantArray));
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(nonConstantArray), std::less<int>()) == boost::end(nonConstantArray));
+
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues),     std::less<int>()) == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues))                       == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues), std::less<int>()) == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues))                   == &randomValues[2] );
+
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(inOrderUntilTheEnd), std::less<int>()) == &inOrderUntilTheEnd[8] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(inOrderUntilTheEnd))                   == &inOrderUntilTheEnd[8] );
+
+//  For zero and one element collections, the comparison predicate should never be called
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues),     std::equal_to<int>()) == a_begin(randomValues));
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues))                           == a_begin(randomValues));
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1, std::equal_to<int>()) == a_begin(randomValues) + 1);
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1 )                      == a_begin(randomValues) + 1);
+
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+        ba::is_sorted ( boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues) )
+        && !ba::is_sorted (a_range(randomValues))
+        && ba::is_sorted_until ( boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues), less) == a_end(strictlyIncreasingValues)
+        && ba::is_sorted_until ( randomValues, less)                                                                 == &randomValues[2]
+    );
+    BOOST_CHECK ( constexpr_res );
+}
+
+
+static void
+test_increasing_decreasing(void)
+{
+    BOOST_CXX14_CONSTEXPR const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
+    BOOST_CXX14_CONSTEXPR const int strictlyDecreasingValues[] = { 9, 8, 7, 6, 5 };
+    BOOST_CXX14_CONSTEXPR const int increasingValues[] = { 1, 2, 2, 2, 5 };
+    BOOST_CXX14_CONSTEXPR const int decreasingValues[] = { 9, 7, 7, 7, 5 };
+    BOOST_CXX14_CONSTEXPR const int randomValues[] = { 3, 6, 1, 2, 7 };
+    BOOST_CXX14_CONSTEXPR const int constantValues[] = { 7, 7, 7, 7, 7 };
+
+    // Test a strictly increasing sequence
+    BOOST_CHECK (  ba::is_strictly_increasing (b_e(strictlyIncreasingValues)));
+    BOOST_CHECK (  ba::is_increasing          (b_e(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (b_e(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_decreasing          (b_e(strictlyIncreasingValues)));
+
+    BOOST_CHECK (  ba::is_strictly_increasing (a_range(strictlyIncreasingValues)));
+    BOOST_CHECK (  ba::is_increasing          (a_range(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (a_range(strictlyIncreasingValues)));
+    BOOST_CHECK ( !ba::is_decreasing          (a_range(strictlyIncreasingValues)));
+
+    // Test a strictly decreasing sequence
+    BOOST_CHECK ( !ba::is_strictly_increasing (b_e(strictlyDecreasingValues)));
+    BOOST_CHECK ( !ba::is_increasing          (b_e(strictlyDecreasingValues)));
+    BOOST_CHECK (  ba::is_strictly_decreasing (b_e(strictlyDecreasingValues)));
+    BOOST_CHECK (  ba::is_decreasing          (b_e(strictlyDecreasingValues)));
+
+    // Test an increasing sequence
+    BOOST_CHECK ( !ba::is_strictly_increasing (b_e(increasingValues)));
+    BOOST_CHECK (  ba::is_increasing          (b_e(increasingValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (b_e(increasingValues)));
+    BOOST_CHECK ( !ba::is_decreasing          (b_e(increasingValues)));
+
+    // Test a decreasing sequence
+    BOOST_CHECK ( !ba::is_strictly_increasing (b_e(decreasingValues)));
+    BOOST_CHECK ( !ba::is_increasing          (b_e(decreasingValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (b_e(decreasingValues)));
+    BOOST_CHECK (  ba::is_decreasing          (b_e(decreasingValues)));
+
+    // Test a random sequence
+    BOOST_CHECK ( !ba::is_strictly_increasing (b_e(randomValues)));
+    BOOST_CHECK ( !ba::is_increasing          (b_e(randomValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (b_e(randomValues)));
+    BOOST_CHECK ( !ba::is_decreasing          (b_e(randomValues)));
+
+    // Test a constant sequence
+    BOOST_CHECK ( !ba::is_strictly_increasing (b_e(constantValues)));
+    BOOST_CHECK (  ba::is_increasing          (b_e(constantValues)));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (b_e(constantValues)));
+    BOOST_CHECK (  ba::is_decreasing          (b_e(constantValues)));
+    
+    // Test an empty sequence
+    BOOST_CHECK (  ba::is_strictly_increasing (strictlyIncreasingValues, strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_increasing          (strictlyIncreasingValues, strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_strictly_decreasing (strictlyIncreasingValues, strictlyIncreasingValues));
+    BOOST_CHECK (  ba::is_decreasing          (strictlyIncreasingValues, strictlyIncreasingValues));
+    
+    // Test a one-element sequence
+    BOOST_CHECK (  ba::is_strictly_increasing (strictlyIncreasingValues, strictlyIncreasingValues+1));
+    BOOST_CHECK (  ba::is_increasing          (strictlyIncreasingValues, strictlyIncreasingValues+1));
+    BOOST_CHECK (  ba::is_strictly_decreasing (strictlyIncreasingValues, strictlyIncreasingValues+1));
+    BOOST_CHECK (  ba::is_decreasing          (strictlyIncreasingValues, strictlyIncreasingValues+1));
+
+    // Test a two-element sequence
+    BOOST_CHECK (  ba::is_strictly_increasing (strictlyIncreasingValues, strictlyIncreasingValues+2));
+    BOOST_CHECK (  ba::is_increasing          (strictlyIncreasingValues, strictlyIncreasingValues+2));
+    BOOST_CHECK ( !ba::is_strictly_decreasing (strictlyIncreasingValues, strictlyIncreasingValues+2));
+    BOOST_CHECK ( !ba::is_decreasing          (strictlyIncreasingValues, strictlyIncreasingValues+2));
+    
+    BOOST_CXX14_CONSTEXPR bool constexpr_res = (
+            ba::is_increasing           (boost::begin(increasingValues),         boost::end(increasingValues))
+        &&  ba::is_decreasing           (boost::begin(decreasingValues),         boost::end(decreasingValues))
+        &&  ba::is_strictly_increasing  (boost::begin(strictlyIncreasingValues), boost::end(strictlyIncreasingValues))
+        &&  ba::is_strictly_decreasing  (boost::begin(strictlyDecreasingValues), boost::end(strictlyDecreasingValues))
+        && !ba::is_strictly_increasing  (boost::begin(increasingValues),         boost::end(increasingValues))
+        && !ba::is_strictly_decreasing  (boost::begin(decreasingValues),         boost::end(decreasingValues))
+    );
+    BOOST_CHECK ( constexpr_res );
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    test_ordered ();
+    test_increasing_decreasing ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/partition_copy_test1.cpp

@@ -0,0 +1,110 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/partition_copy.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <boost/algorithm/cxx11/all_of.hpp>
+#include <boost/algorithm/cxx11/none_of.hpp>
+#include <string>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+template <typename Container, typename Predicate>
+void test_sequence ( const Container &c, Predicate comp ) {
+    std::vector<typename Container::value_type> v1, v2;
+    
+    v1.clear (); v2.clear ();
+    ba::partition_copy ( c.begin (), c.end (), 
+                std::back_inserter (v1), std::back_inserter (v2), comp );
+//  std::cout << "Sizes(1): " << c.size () << " -> { " << v1.size () << ", " << v2.size () << " }" << std::endl;
+    BOOST_CHECK ( v1.size () + v2.size () == c.size ());
+    BOOST_CHECK ( ba::all_of  ( v1.begin (), v1.end (), comp ));
+    BOOST_CHECK ( ba::none_of ( v2.begin (), v2.end (), comp ));
+
+    v1.clear (); v2.clear ();
+    ba::partition_copy ( c, std::back_inserter (v1), std::back_inserter ( v2 ), comp );
+//  std::cout << "Sizes(2): " << c.size () << " -> { " << v1.size () << ", " << v2.size () << " }" << std::endl;
+    BOOST_CHECK ( v1.size () + v2.size () == c.size ());
+    BOOST_CHECK ( ba::all_of  ( v1, comp ));
+    BOOST_CHECK ( ba::none_of ( v2, comp ));
+    }
+
+template <typename T>
+struct less_than {
+public:
+    BOOST_CXX14_CONSTEXPR less_than ( T foo ) : val ( foo ) {}
+    BOOST_CXX14_CONSTEXPR less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    BOOST_CXX14_CONSTEXPR bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+    };
+
+bool is_even ( int v ) { return v % 2 == 0; }
+
+void test_sequence1 () {
+    std::vector<int> v;
+    
+    v.clear ();
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_sequence ( v, less_than<int>(3));      // no elements
+    test_sequence ( v, less_than<int>(6));      // only the first element
+    test_sequence ( v, less_than<int>(10));
+    test_sequence ( v, less_than<int>(99));     // all elements satisfy 
+
+//  With bidirectional iterators.
+    std::list<int> l;
+    for ( int i = 5; i < 16; ++i )
+        l.push_back ( i );
+    test_sequence ( l, less_than<int>(3));      // no elements
+    test_sequence ( l, less_than<int>(6));      // only the first element
+    test_sequence ( l, less_than<int>(10));
+    test_sequence ( l, less_than<int>(99));     // all elements satisfy 
+
+    }
+
+    
+BOOST_CXX14_CONSTEXPR bool test_constexpr () {
+    int in[] = {1, 1, 2};
+    int out_true[3] = {0};
+    int out_false[3] = {0};
+    bool res = true;
+    ba::partition_copy( in, in + 3, out_true, out_false, less_than<int>(2) );
+    res = (res && ba::all_of(out_true, out_true + 2, less_than<int>(2)) );
+    res = (res && ba::none_of(out_false, out_false + 1, less_than<int>(2)) );
+    
+// clear elements
+    out_true [0] = 0;
+    out_true [1] = 0;
+    out_false[0] = 0;
+    
+    ba::partition_copy( in, out_true, out_false, less_than<int>(2));
+    res = ( res && ba::all_of(out_true, out_true + 2, less_than<int>(2)));
+    res = ( res && ba::none_of(out_false, out_false + 1, less_than<int>(2)));
+    return res;
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+  BOOST_CXX14_CONSTEXPR bool constexpr_res = test_constexpr ();
+  BOOST_CHECK ( constexpr_res );
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/partition_point_test1.cpp

@@ -0,0 +1,100 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/partition_point.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <string>
+#include <vector>
+#include <list>
+
+namespace ba = boost::algorithm;
+// namespace ba = boost;
+
+template <typename Container>
+typename Container::iterator offset_to_iter ( Container &v, int offset ) {
+    typename Container::iterator retval;
+    
+    if ( offset >= 0 ) {
+        retval = v.begin ();
+        std::advance ( retval, offset );
+        }
+    else {
+        retval = v.end ();
+        std::advance ( retval, offset + 1 );
+        }
+    return retval;
+    }
+
+template <typename Container, typename Predicate>
+void test_sequence ( Container &v, Predicate comp, int expected ) {
+    typename Container::iterator res, exp;
+    
+    res = ba::partition_point ( v.begin (), v.end (), comp );
+    exp = offset_to_iter ( v, expected );
+    BOOST_CHECK ( exp == res );
+
+//  Duplicate the last element; this checks for any even/odd problems
+    v.push_back ( * v.rbegin ());
+    res = ba::partition_point ( v.begin (), v.end (), comp );
+    exp = offset_to_iter ( v, expected );
+    BOOST_CHECK ( exp == res );
+
+//  Range based test
+    res = ba::partition_point ( v, comp );
+    exp = offset_to_iter ( v, expected );
+    BOOST_CHECK ( exp == res );
+    }
+
+template <typename T>
+struct less_than {
+public:
+    less_than ( T foo ) : val ( foo ) {}
+    less_than ( const less_than &rhs ) : val ( rhs.val ) {}
+
+    bool operator () ( const T &v ) const { return v < val; }
+private:
+    less_than ();
+    less_than operator = ( const less_than &rhs );
+    T val;
+    };
+
+
+void test_sequence1 () {
+    std::vector<int> v;
+    
+    v.clear ();
+    for ( int i = 5; i < 15; ++i )
+        v.push_back ( i );
+    test_sequence ( v, less_than<int>(3),  0 ); // no elements
+    test_sequence ( v, less_than<int>(6),  1 );    // only the first element
+    test_sequence ( v, less_than<int>(10), 5 );
+    test_sequence ( v, less_than<int>(99), -1 );   // all elements satisfy 
+
+//  With bidirectional iterators.
+    std::list<int> l;
+    for ( int i = 5; i < 15; ++i )
+        l.push_back ( i );
+    test_sequence ( l, less_than<int>(3),  0 ); // no elements
+    test_sequence ( l, less_than<int>(6),  1 );    // only the first element
+    test_sequence ( l, less_than<int>(10), 5 );
+    test_sequence ( l, less_than<int>(99), -1 );   // all elements satisfy 
+
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_sequence1 ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/partition_subrange_test.cpp

@@ -0,0 +1,170 @@
+#include <boost/config.hpp>
+#include <boost/algorithm/sort_subrange.hpp>
+#include <boost/algorithm/cxx11/is_sorted.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <iostream>
+
+#if (__cplusplus >= 201103L) || defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)
+#include <random>
+
+std::default_random_engine gen;
+template<typename RandomIt>
+void do_shuffle(RandomIt first, RandomIt last)
+{ std::shuffle(first, last, gen); }
+#else
+template<typename RandomIt>
+void do_shuffle(RandomIt first, RandomIt last)
+{ std::random_shuffle(first, last); }
+#endif
+
+namespace ba = boost::algorithm;
+
+template <typename Iter>
+void check_sequence ( Iter first, Iter last, Iter sf, Iter sl )
+{
+// 	for (Iter i = first; i < last; ++i) {
+// 		if (i != first) std::cout << ' ';
+// 		if (i == sf) std::cout << ">";
+// 		std::cout << *i;
+// 		if (i == sl) std::cout << "<";
+// 		}
+// 	if (sl == last) std::cout << "<";
+// 	std::cout << '\n';
+
+	if (sf == sl) return;
+	for (Iter i = first; i < sf; ++i)
+		BOOST_CHECK(*i < *sf);
+	for (Iter i = sf; i < sl; ++i) {
+		if (first != sf) // if there is an element before the subrange
+			BOOST_CHECK(*i > *(sf-1));
+		if (last != sl) // if there is an element after the subrange
+			BOOST_CHECK(*i < *sl);
+		}
+	for (Iter i = sl; i < last; ++i)
+		BOOST_CHECK(*(sl-1) < *i);
+}
+
+template <typename Iter, typename Pred>
+void check_sequence ( Iter first, Iter last, Iter sf, Iter sl, Pred p )
+{
+	if (sf == sl) return;
+	for (Iter i = first; i < sf; ++i)
+		BOOST_CHECK(p(*i, *sf));
+	for (Iter i = sf; i < sl; ++i) {
+		if (first != sf) // if there is an element before the subrange
+			BOOST_CHECK(p(*(sf-1), *i));
+		if (last != sl) // if there is an element after the subrange
+			BOOST_CHECK(p(*i, *sl));
+		}
+	for (Iter i = sl; i < last; ++i)
+		BOOST_CHECK(p(*(sl-1), *i));
+
+}
+
+// 	for ( int i = 0; i < v.size(); ++i )
+// 		std::cout << v[i] << ' ';
+// 	std::cout << std::endl;
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+	{
+	std::vector<int> v;
+	for ( int i = 0; i < 10; ++i )
+		v.push_back(i);
+
+	const std::vector<int>::iterator b = v.begin();
+	ba::partition_subrange(b, v.end(), b + 3, b + 6);
+	check_sequence        (b, v.end(), b + 3, b + 6);
+
+// 	BOOST_CHECK_EQUAL(v[3], 3);
+// 	BOOST_CHECK_EQUAL(v[4], 4);
+// 	BOOST_CHECK_EQUAL(v[5], 5);
+
+//	Mix them up and try again - single element
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b + 7, b + 8);
+	check_sequence        (b, v.end(), b + 7, b + 8);
+
+// 	BOOST_CHECK_EQUAL(v[7], 7);
+
+//	Mix them up and try again - at the end
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b + 7, v.end());
+	check_sequence        (b, v.end(), b + 7, v.end());
+
+// 	BOOST_CHECK_EQUAL(v[7], 7);
+// 	BOOST_CHECK_EQUAL(v[8], 8);
+// 	BOOST_CHECK_EQUAL(v[9], 9);
+
+//	Mix them up and try again - at the beginning
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, b + 2);
+	check_sequence        (b, v.end(), b, b + 2);
+
+// 	BOOST_CHECK_EQUAL(v[0], 0);
+// 	BOOST_CHECK_EQUAL(v[1], 1);
+
+//	Mix them up and try again - empty subrange
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, b);
+	check_sequence        (b, v.end(), b, b);
+
+//	Mix them up and try again - entire subrange
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, v.end());
+	check_sequence        (b, v.end(), b, v.end());
+	}
+
+	{
+	std::vector<int> v;
+	for ( int i = 0; i < 10; ++i )
+		v.push_back(i);
+
+	const std::vector<int>::iterator b = v.begin();
+	ba::partition_subrange(b, v.end(), b + 3, b + 6, std::greater<int>());
+	check_sequence        (b, v.end(), b + 3, b + 6, std::greater<int>());
+
+// 	BOOST_CHECK_EQUAL(v[3], 6);
+// 	BOOST_CHECK_EQUAL(v[4], 5);
+// 	BOOST_CHECK_EQUAL(v[5], 4);
+
+//	Mix them up and try again - single element
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b + 7, b + 8, std::greater<int>());
+	check_sequence        (b, v.end(), b + 7, b + 8, std::greater<int>());
+
+// 	BOOST_CHECK_EQUAL(v[7], 2);
+
+//	Mix them up and try again - at the end
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b + 7, v.end(), std::greater<int>());
+	check_sequence        (b, v.end(), b + 7, v.end(), std::greater<int>());
+
+// 	BOOST_CHECK_EQUAL(v[7], 2);
+// 	BOOST_CHECK_EQUAL(v[8], 1);
+// 	BOOST_CHECK_EQUAL(v[9], 0);
+
+//	Mix them up and try again - at the beginning
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, b + 2, std::greater<int>());
+	check_sequence        (b, v.end(), b, b + 2, std::greater<int>());
+
+// 	BOOST_CHECK_EQUAL(v[0], 9);
+// 	BOOST_CHECK_EQUAL(v[1], 8);
+
+//	Mix them up and try again - empty subrange
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, b, std::greater<int>());
+	check_sequence        (b, v.end(), b, b, std::greater<int>());
+
+//	Mix them up and try again - entire subrange
+	do_shuffle(v.begin(), v.end());
+	ba::partition_subrange(b, v.end(), b, v.end(), std::greater<int>());
+	check_sequence        (b, v.end(), b, v.end(), std::greater<int>());
+	}
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/power_fail1.cpp

@@ -0,0 +1,24 @@
+/* 
+   Copyright (c) Marshall Clow 2014.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/algorithm.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+//  Second argument must be an integral value
+    BOOST_CHECK ( ba::power(1, 1.0) == 1);
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/power_test.cpp

@@ -0,0 +1,84 @@
+/* 
+   Copyright (c) Marshall Clow 2014.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <iostream>
+#include <functional>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/algorithm.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+void test_power ()
+{
+    BOOST_CHECK ( ba::power(0, 0) == 1);
+    BOOST_CHECK ( ba::power(5, 0) == 1);
+    BOOST_CHECK ( ba::power(1, 1) == 1);
+    BOOST_CHECK ( ba::power(1, 4) == 1);
+    BOOST_CHECK ( ba::power(3, 2) == 9);
+    BOOST_CHECK ( ba::power(2, 3) == 8);
+    BOOST_CHECK ( ba::power(3, 3) == 27);
+    BOOST_CHECK ( ba::power(2, 30) == 0x40000000);
+    BOOST_CHECK ( ba::power(5L, 10) == 3125*3125);
+    BOOST_CHECK ( ba::power(18, 3) == 18*18*18);
+    
+    BOOST_CHECK ( ba::power(3,2) == ba::power(3,2, std::multiplies<int>()));
+    BOOST_CHECK ( ba::power(3,2, std::plus<int>()) == 6);
+}
+
+
+void test_power_constexpr ()
+{
+    BOOST_CXX14_CONSTEXPR bool check_zero_power1 =
+        ba::power(0, 0) == 1;
+    BOOST_CHECK(check_zero_power1);
+    BOOST_CXX14_CONSTEXPR bool check_zero_power2 =
+        ba::power(5, 0) == 1;
+    BOOST_CHECK(check_zero_power2);
+    BOOST_CXX14_CONSTEXPR bool check_one_base1 =
+        ba::power(1, 1) == 1;
+    BOOST_CHECK(check_one_base1);
+    BOOST_CXX14_CONSTEXPR bool check_one_base2 =
+        ba::power(1, 4) == 1;
+    BOOST_CHECK(check_one_base2);
+    BOOST_CXX14_CONSTEXPR bool check_power1 = 
+        ba::power(3, 2) == 9;
+    BOOST_CHECK(check_power1);
+    BOOST_CXX14_CONSTEXPR bool check_power2 = 
+        ba::power(2, 3) == 8;
+    BOOST_CHECK(check_power2);
+    BOOST_CXX14_CONSTEXPR bool check_power3 = 
+        ba::power(3, 3) == 27;
+    BOOST_CHECK(check_power3);
+    BOOST_CXX14_CONSTEXPR bool check_power4 = 
+        ba::power(2, 30) == 0x40000000;
+    BOOST_CHECK(check_power4);
+    BOOST_CXX14_CONSTEXPR bool check_power5 = 
+        ba::power(5L, 10) == 3125*3125;
+    BOOST_CHECK(check_power5);
+    BOOST_CXX14_CONSTEXPR bool check_power6 = 
+        ba::power(18, 3) == 18*18*18;
+    BOOST_CHECK(check_power6);
+    
+    BOOST_CXX14_CONSTEXPR bool check_multiple = 
+        ba::power(3, 2, std::multiplies<int>()) == ba::power(3, 2);
+    BOOST_CHECK(check_multiple);
+    BOOST_CXX14_CONSTEXPR bool check_plus = 
+        ba::power(3, 2, std::plus<int>()) == 6;
+    BOOST_CHECK(check_plus);
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main ) {
+  test_power ();
+  test_power_constexpr ();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/reduce_test.cpp

@@ -0,0 +1,128 @@
+/*
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx17/reduce.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+template <class Iter, class T, class Op>
+void
+test_reduce(Iter first, Iter last, T init, Op op, T x)
+{
+    BOOST_CHECK(ba::reduce(first, last, init, op) == x);
+}
+
+template <class Iter, class T, class Op>
+void
+test_reduce(Iter first, Iter last, Op op, T x)
+{
+    BOOST_CHECK(ba::reduce(first, last, op) == x);
+}
+
+template <class Iter, class T>
+void
+test_reduce(Iter first, Iter last, T x)
+{
+    BOOST_CHECK(ba::reduce(first, last) == x);
+}
+
+template <class Iter>
+void
+test_init_op()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test_reduce(Iter(ia), Iter(ia), 0, std::plus<int>(), 0);
+    test_reduce(Iter(ia), Iter(ia), 1, std::multiplies<int>(), 1);
+    test_reduce(Iter(ia), Iter(ia+1), 0, std::plus<int>(), 1);
+    test_reduce(Iter(ia), Iter(ia+1), 2, std::multiplies<int>(), 2);
+    test_reduce(Iter(ia), Iter(ia+2), 0, std::plus<int>(), 3);
+    test_reduce(Iter(ia), Iter(ia+2), 3, std::multiplies<int>(), 6);
+    test_reduce(Iter(ia), Iter(ia+sa), 0, std::plus<int>(), 21);
+    test_reduce(Iter(ia), Iter(ia+sa), 4, std::multiplies<int>(), 2880);
+}
+
+void test_reduce_init_op()
+{
+    test_init_op<input_iterator<const int*> >();
+    test_init_op<forward_iterator<const int*> >();
+    test_init_op<bidirectional_iterator<const int*> >();
+    test_init_op<random_access_iterator<const int*> >();
+    test_init_op<const int*>();
+
+    {
+    char ia[] = {1, 2, 3, 4, 5, 6, 7, 8};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    unsigned res = boost::algorithm::reduce(ia, ia+sa, 1U, std::multiplies<unsigned>());
+    BOOST_CHECK(res == 40320);		// 8! will not fit into a char
+    }
+}
+
+template <class Iter>
+void
+test_init()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test_reduce(Iter(ia), Iter(ia), 0, 0);
+    test_reduce(Iter(ia), Iter(ia), 1, 1);
+    test_reduce(Iter(ia), Iter(ia+1), 0, 1);
+    test_reduce(Iter(ia), Iter(ia+1), 2, 3);
+    test_reduce(Iter(ia), Iter(ia+2), 0, 3);
+    test_reduce(Iter(ia), Iter(ia+2), 3, 6);
+    test_reduce(Iter(ia), Iter(ia+sa), 0, 21);
+    test_reduce(Iter(ia), Iter(ia+sa), 4, 25);
+}
+
+void test_reduce_init()
+{
+    test_init<input_iterator<const int*> >();
+    test_init<forward_iterator<const int*> >();
+    test_init<bidirectional_iterator<const int*> >();
+    test_init<random_access_iterator<const int*> >();
+    test_init<const int*>();
+}
+
+
+template <class Iter>
+void
+test()
+{
+    int ia[] = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    test_reduce(Iter(ia), Iter(ia), 0);
+    test_reduce(Iter(ia), Iter(ia+1), 1);
+    test_reduce(Iter(ia), Iter(ia+2), 3);
+    test_reduce(Iter(ia), Iter(ia+sa), 21);
+}
+
+void test_reduce()
+{
+    test<input_iterator<const int*> >();
+    test<forward_iterator<const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_reduce();
+  test_reduce_init();
+  test_reduce_init_op();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_fail1.cpp

@@ -0,0 +1,24 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <boost/algorithm/searching/boyer_moore.hpp>
+
+int main( int , char* [] )
+{
+    std::vector<char>   cv;
+    std::vector<int>    iv;
+    
+//  Should fail to compile because the underlying types are different
+//  They are (almost certainly) different sizes
+    (void) boost::algorithm::boyer_moore_search (
+        cv.begin (), cv.end (), iv.begin (), iv.end ());
+
+   return 0;
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_fail2.cpp

@@ -0,0 +1,25 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <boost/cstdint.hpp>
+#include <boost/algorithm/searching/boyer_moore.hpp>
+
+int main( int , char* [] )
+{
+    std::vector<boost::uint8_t> cv;
+    std::vector<boost:: int8_t> iv;
+    
+//  Should fail to compile because the underlying types are different
+//  They are the same size, but one is signed, and the other is not.
+    (void) boost::algorithm::boyer_moore_search (
+        cv.begin (), cv.end (), iv.begin (), iv.end ());
+
+   return 0;
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_fail3.cpp

@@ -0,0 +1,19 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <boost/algorithm/searching/boyer_moore.hpp>
+
+int main( int , char* [] )
+{
+//  Should fail to compile because the search objects are not default-constructible
+    boost::algorithm::boyer_moore<std::vector<char>::iterator> bm;
+   
+   return 0;
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test1.cpp

@@ -0,0 +1,285 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <string>
+#include <vector>
+
+
+namespace ba = boost::algorithm;
+
+template <typename Iter>
+std::string make_str ( Iter first, std::size_t len ) {
+    std::string retVal ( len + 2, '\'' );
+    std::copy ( first, first+len, retVal.begin () + 1);
+    return retVal;
+    }
+
+namespace {
+
+//  Check using iterators
+    template<typename Container>
+    void check_one_iter ( const Container &haystack, const std::string &needle, int expected ) {
+        typedef typename Container::const_iterator iter_type;
+        typedef typename std::pair<iter_type, iter_type> ret_type;
+        typedef std::string::const_iterator pattern_type;
+
+        iter_type hBeg = haystack.begin ();
+        iter_type hEnd = haystack.end ();
+        pattern_type nBeg = needle.begin ();
+        pattern_type nEnd = needle.end ();
+
+//      iter_type ret0  = std::search                     (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret1  = ba::boyer_moore_search          (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret1r = ba::boyer_moore_search          (haystack, nBeg, nEnd);
+        ret_type ret2  = ba::boyer_moore_horspool_search (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret3  = ba::knuth_morris_pratt_search   (hBeg, hEnd, nBeg, nEnd);
+
+        iter_type it0  = std::search                     (hBeg, hEnd, nBeg, nEnd);
+//         iter_type it1  = ret1.first;
+//         iter_type it1r = ret1r.first;
+//         iter_type it2  = ret2.first;
+//         iter_type it3  = ret3.first;
+        const int dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first );
+
+        std::cout << "(Iterators) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl;
+        try {
+            if ( it0 != ret1.first ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between std::search and boyer-moore search" ));
+                }
+
+            if ( ret1.first != ret1r.first || ret1.second != ret1r.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between iterator and range boyer_moore search" ));
+                }
+
+            if ( ret1.first != ret2.first || ret1.second != ret2.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and boyer-moore-horspool search" ));
+                }
+
+            if ( ret1.first != ret3.first || ret1.second != ret3.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and knuth-morris-pratt search" ));
+                }
+
+            }
+
+        catch ( ... ) {
+            std::cout << "Searching for: " << needle << std::endl;
+            std::cout << "Expected: " << expected << "\n";
+            std::cout << "  std:    " << std::distance ( hBeg, it0 ) << "\n";
+            std::cout << "  bm:     " << std::distance ( hBeg, ret1.first ) << "\n";
+            std::cout << "  bm(r):  " << std::distance ( hBeg, ret1r.first ) << "\n";
+            std::cout << "  bmh:    " << std::distance ( hBeg, ret2.first ) << "\n";
+            std::cout << "  kpm:    " << std::distance ( hBeg, ret3.first )<< "\n";
+            std::cout << std::flush;
+            throw ;
+            }
+
+        BOOST_CHECK_EQUAL ( dist, expected );
+        }
+
+//  Check using pointers
+//    We're assuming that the container implements contiguous storage here.
+    template<typename Container>
+    void check_one_pointer ( const Container &haystack, const std::string &needle, int expected ) {
+        typedef const typename Container::value_type *ptr_type;
+        typedef typename std::pair<ptr_type, ptr_type> ret_type;
+
+        ptr_type hBeg = haystack.size () == 0 ? NULL : &*haystack.begin ();
+        ptr_type hEnd = hBeg + haystack.size ();
+        ptr_type nBeg = needle.size () == 0 ? NULL : &*needle.begin ();
+        ptr_type nEnd = nBeg + needle.size ();
+
+        ptr_type it0  = std::search                     (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret1 = ba::boyer_moore_search          (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret2 = ba::boyer_moore_horspool_search (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret3 = ba::knuth_morris_pratt_search   (hBeg, hEnd, nBeg, nEnd);
+        const int dist = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first );
+
+        std::cout << "(Pointers) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl;
+        try {
+            if ( it0 != ret1.first ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between std::search and boyer-moore search" ));
+                }
+
+            if ( ret1.first != ret2.first || ret1.second != ret2.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and boyer-moore-horspool search" ));
+                }
+
+            if ( ret1.first != ret3.first || ret1.second != ret3.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and knuth-morris-pratt search" ));
+                }
+
+            }
+
+        catch ( ... ) {
+            std::cout << "Searching for: " << needle << std::endl;
+            std::cout << "Expected: " << expected << "\n";
+            std::cout << "  std:    " << std::distance ( hBeg, it0 ) << "\n";
+            std::cout << "  bm:     " << std::distance ( hBeg, ret1.first ) << "\n";
+            std::cout << "  bmh:    " << std::distance ( hBeg, ret2.first ) << "\n";
+            std::cout << "  kpm:    " << std::distance ( hBeg, ret3.first )<< "\n";
+            std::cout << std::flush;
+            throw ;
+            }
+
+        BOOST_CHECK_EQUAL ( dist, expected );
+        }
+
+//  Check using objects
+    template<typename Container>
+    void check_one_object ( const Container &haystack, const std::string &needle, int expected ) {
+        typedef typename Container::const_iterator iter_type;
+        typedef typename std::pair<iter_type, iter_type> ret_type;
+        typedef std::string::const_iterator pattern_type;
+
+        iter_type hBeg = haystack.begin ();
+        iter_type hEnd = haystack.end ();
+        pattern_type nBeg = needle.begin ();
+        pattern_type nEnd = needle.end ();
+
+        ba::boyer_moore<pattern_type>          bm_r  = ba::make_boyer_moore ( needle );
+        ba::boyer_moore<pattern_type>          bm    ( nBeg, nEnd );
+        ba::boyer_moore_horspool<pattern_type> bmh   ( nBeg, nEnd );
+        ba::knuth_morris_pratt<pattern_type>   kmp   ( nBeg, nEnd );
+        
+        iter_type it0   = std::search  (hBeg, hEnd, nBeg, nEnd);
+        ret_type ret1   = bm           (hBeg, hEnd);
+        ret_type ret1r  = bm           (haystack);
+        ret_type retr1  = bm_r         (hBeg, hEnd);
+       ret_type retr1r = bm_r         (haystack);
+        ret_type ret2   = bmh          (hBeg, hEnd);
+        ret_type ret3   = kmp          (hBeg, hEnd);
+        const int dist  = ret1.first == hEnd ? -1 : std::distance ( hBeg, ret1.first );
+
+        std::cout << "(Objects) Pattern is " << needle.length () << ", haysstack is " << haystack.length () << " chars long; " << std::endl;
+        try {
+            if ( it0 != ret1.first ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between std::search and boyer-moore search" ));
+                }
+
+            if ( ret1.first != ret1r.first || ret1.second != ret1r.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between iterator and range boyer_moore search(1)" ));
+                }
+
+            if ( ret1.first != retr1.first || ret1.second != retr1.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between iterator and range boyer_moore search(2)" ));
+                }
+
+            if ( ret1.first != retr1r.first || ret1.second != retr1r.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between iterator and range boyer_moore search(3)" ));
+                }
+
+            if ( ret1.first != ret2.first || ret1.second != ret2.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and boyer-moore-horspool search" ));
+                }
+
+            if ( ret1.first != ret3.first || ret1.second != ret3.second ) {
+                throw std::runtime_error ( 
+                    std::string ( "results mismatch between boyer-moore and knuth-morris-pratt search" ));
+                }
+
+            }
+
+        catch ( ... ) {
+            std::cout << "Searching for: " << needle << std::endl;
+            std::cout << "Expected:  " << expected << "\n";
+            std::cout << "  std:     " << std::distance ( hBeg, it0 ) << "\n";
+            std::cout << "  bm:      " << std::distance ( hBeg, ret1.first ) << "\n";
+            std::cout << "  bm(r1):  " << std::distance ( hBeg, ret1r.first ) << "\n";
+            std::cout << "  bm(r2):  " << std::distance ( hBeg, retr1.first ) << "\n";
+            std::cout << "  bm(r3):  " << std::distance ( hBeg, retr1r.first ) << "\n";
+            std::cout << "  bmh:     " << std::distance ( hBeg, ret2.first ) << "\n";
+            std::cout << "  kpm:    " << std::distance ( hBeg, ret3.first )<< "\n";
+            std::cout << std::flush;
+            throw ;
+            }
+
+        BOOST_CHECK_EQUAL ( dist, expected );
+        }
+
+
+    template<typename Container>
+    void check_one ( const Container &haystack, const std::string &needle, int expected ) {
+        check_one_iter ( haystack, needle, expected );
+        check_one_pointer ( haystack, needle, expected );
+        check_one_object ( haystack, needle, expected );
+        }
+    }
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    std::string haystack1 ( "NOW AN FOWE\220ER ANNMAN THE ANPANMANEND" );
+    std::string needle1   ( "ANPANMAN" );
+    std::string needle2   ( "MAN THE" );
+    std::string needle3   ( "WE\220ER" );
+    std::string needle4   ( "NOW " );   //  At the beginning
+    std::string needle5   ( "NEND" );   //  At the end
+    std::string needle6   ( "NOT FOUND" );  // Nowhere
+    std::string needle7   ( "NOT FO\340ND" );   // Nowhere
+
+    std::string haystack2 ( "ABC ABCDAB ABCDABCDABDE" );
+    std::string needle11  ( "ABCDABD" );
+
+    std::string haystack3 ( "abra abracad abracadabra" );
+    std::string needle12  ( "abracadabra" );
+
+    std::string needle13   ( "" );
+    std::string haystack4  ( "" );
+
+    check_one ( haystack1, needle1, 26 );
+    check_one ( haystack1, needle2, 18 );
+    check_one ( haystack1, needle3,  9 );
+    check_one ( haystack1, needle4,  0 );
+    check_one ( haystack1, needle5, 33 );
+    check_one ( haystack1, needle6, -1 );
+    check_one ( haystack1, needle7, -1 );
+
+    check_one ( needle1, haystack1, -1 );   // cant find long pattern in short corpus
+    check_one ( haystack1, haystack1, 0 );  // find something in itself
+    check_one ( haystack2, haystack2, 0 );  // find something in itself
+
+    check_one ( haystack2, needle11, 15 );
+    check_one ( haystack3, needle12, 13 );
+
+    check_one ( haystack1, needle13, 0 );   // find the empty string 
+    check_one ( haystack4, needle1, -1 );  // can't find in an empty haystack
+
+//  Mikhail Levin <svarneticist@gmail.com> found a problem, and this was the test
+//  that triggered it.
+
+  const std::string mikhail_pattern =   
+"GATACACCTACCTTCACCAGTTACTCTATGCACTAGGTGCGCCAGGCCCATGCACAAGGGCTTGAGTGGATGGGAAGGA"
+"TGTGCCCTAGTGATGGCAGCATAAGCTACGCAGAGAAGTTCCAGGGCAGAGTCACCATGACCAGGGACACATCCACGAG"
+"CACAGCCTACATGGAGCTGAGCAGCCTGAGATCTGAAGACACGGCCATGTATTACTGTGGGAGAGATGTCTGGAGTGGT"
+"TATTATTGCCCCGGTAATATTACTACTACTACTACTACATGGACGTCTGGGGCAAAGGGACCACG"
+;
+    const std::string mikhail_corpus = std::string (8, 'a') + mikhail_pattern;
+
+    check_one ( mikhail_corpus, mikhail_pattern, 8 );
+    }

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test2.cpp

@@ -0,0 +1,153 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <ctime>        // for clock_t
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <algorithm>
+#include <vector>
+
+typedef std::vector<char> vec;
+#define NUM_TRIES   100
+
+#define runOne(call, refDiff)   { \
+    std::clock_t bTime, eTime;                              \
+    bTime = std::clock ();                                  \
+    for ( i = 0; i < NUM_TRIES; ++i ) {                     \
+        res = boost::algorithm::call                        \
+            ( haystack.begin (), haystack.end (),           \
+                        needle.begin (), needle.end ());    \
+        if ( res != exp ) {                                 \
+            std::cout << "On run # " << i << " expected "   \
+                << exp.first - haystack.begin () << " got "       \
+                << res.first - haystack.begin () << std::endl;    \
+            throw std::runtime_error                        \
+                ( "Unexpected result from " #call );        \
+            }                                               \
+        }                                                   \
+    eTime = std::clock ();                                  \
+    printRes ( #call, eTime - bTime, refDiff ); }
+
+#define runObject(obj, refDiff) { \
+    std::clock_t bTime, eTime;                              \
+    bTime = std::clock ();                                  \
+    boost::algorithm::obj <vec::const_iterator>             \
+                s_o ( needle.begin (), needle.end ());      \
+    for ( i = 0; i < NUM_TRIES; ++i ) {                     \
+        res = s_o ( haystack.begin (), haystack.end ());    \
+        if ( res != exp ) {                                 \
+            std::cout << "On run # " << i << " expected "   \
+            << exp.first - haystack.begin () << " got "           \
+            << res.first - haystack.begin () << std::endl;        \
+            throw std::runtime_error                        \
+            ( "Unexpected result from " #obj " object" );   \
+            }                                               \
+        }                                                   \
+    eTime = std::clock ();                                  \
+    printRes ( #obj " object", eTime - bTime, refDiff ); }
+    
+
+
+namespace {
+
+    vec ReadFromFile ( const char *name ) {
+        std::ifstream in ( name, std::ios_base::binary | std::ios_base::in );
+        vec retVal;
+        std::istream_iterator<char, char> begin(in);
+        std::istream_iterator<char, char> end;
+        
+        std::copy ( begin, end, std::back_inserter ( retVal ));
+        return retVal;
+        }
+    
+    void printRes ( const char *prompt, unsigned long diff, unsigned long stdDiff ) {
+        std::cout 
+            << std::setw(34) << prompt << " "
+            << std::setw(6)  << (  1.0 * diff) / CLOCKS_PER_SEC << " seconds\t"
+            << std::setw(5)  << (100.0 * diff) / stdDiff << "% \t" 
+            << std::setw(12) << diff;
+        if ( diff > stdDiff ) 
+            std::cout << " !!";
+        std::cout << std::endl;
+        }
+    
+    void check_one ( const vec &haystack, const vec &needle, int expected ) {
+        std::size_t i;
+        std::clock_t sTime;
+        unsigned long stdDiff;
+        
+        std::pair<vec::const_iterator, vec::const_iterator> res;
+        std::pair<vec::const_iterator, vec::const_iterator> exp;        // the expected result
+        vec::const_iterator exp_start;
+        
+        if ( expected >= 0 )
+            exp_start = haystack.begin () + expected;
+        else if ( expected == -1 )
+            exp_start = haystack.end ();      // we didn't find it!
+        else if ( expected == -2 )
+            exp_start = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        else    
+            throw std::logic_error ( "Expected must be -2, -1, or >= 0" );
+
+		if ( expected == -1 )
+			exp = std::make_pair(haystack.end(), haystack.end());
+		else
+			exp = std::make_pair(exp_start, exp_start + needle.size());
+			
+        std::cout << "Pattern is " << needle.size ()   << " entries long" << std::endl;
+        std::cout << "Corpus  is " << haystack.size () << " entries long" << std::endl;
+
+    //  First, the std library search
+        sTime = std::clock ();
+        for ( i = 0; i < NUM_TRIES; ++i ) {
+            vec::const_iterator s_res = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+            if ( s_res != exp.first ) {
+                std::cout << "On run # " << i << " expected " << exp.first - haystack.begin () << " got " << s_res - haystack.begin () << std::endl;
+                throw std::runtime_error ( "Unexpected result from std::search" );
+                }
+            }
+        stdDiff = std::clock () - sTime;
+        printRes ( "std::search", stdDiff, stdDiff );
+
+        runOne    ( boyer_moore_search,          stdDiff );
+        runObject ( boyer_moore,                 stdDiff );
+        runOne    ( boyer_moore_horspool_search, stdDiff );
+        runObject ( boyer_moore_horspool,        stdDiff );
+        runOne    ( knuth_morris_pratt_search,   stdDiff );
+        runObject ( knuth_morris_pratt,          stdDiff );
+        }
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    vec c1  = ReadFromFile ( "search_test_data/0001.corpus" );
+    vec p1b = ReadFromFile ( "search_test_data/0001b.pat" );
+    vec p1e = ReadFromFile ( "search_test_data/0001e.pat" );
+    vec p1n = ReadFromFile ( "search_test_data/0001n.pat" );
+    vec p1f = ReadFromFile ( "search_test_data/0001f.pat" );
+    
+    std::cout << std::ios::fixed << std::setprecision(4);
+//  std::cout << "Corpus is " << c1.size () << " entries long\n";
+    std::cout << "--- Beginning ---" << std::endl;
+    check_one ( c1, p1b, 0 );       //  Find it at position zero
+    std::cout << "---- Middle -----" << std::endl;
+    check_one ( c1, p1f, -2 );      //  Don't know answer
+    std::cout << "------ End ------" << std::endl;
+    check_one ( c1, p1e, c1.size() - p1e.size ());  
+    std::cout << "--- Not found ---" << std::endl;
+    check_one ( c1, p1n, -1 );      //  Not found
+    }

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test3.cpp

@@ -0,0 +1,153 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <ctime>        // for clock_t
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+typedef std::vector<std::string> vec;
+#define NUM_TRIES   100
+
+#define runOne(call, refDiff)   { \
+    std::clock_t bTime, eTime;                              \
+    bTime = std::clock ();                                  \
+    for ( i = 0; i < NUM_TRIES; ++i ) {                     \
+        res = boost::algorithm::call                        \
+            ( haystack.begin (), haystack.end (),           \
+                        needle.begin (), needle.end ());    \
+        if ( res != exp ) {                                 \
+            std::cout << "On run # " << i << " expected "   \
+                << exp.first - haystack.begin () << " got "       \
+                << res.first - haystack.begin () << std::endl;    \
+            throw std::runtime_error                        \
+                ( "Unexpected result from " #call );        \
+            }                                               \
+        }                                                   \
+    eTime = std::clock ();                                  \
+    printRes ( #call, eTime - bTime, refDiff ); }
+    
+#define runObject(obj, refDiff) { \
+    std::clock_t bTime, eTime;                              \
+    bTime = std::clock ();                                  \
+    boost::algorithm::obj <vec::const_iterator>             \
+                s_o ( needle.begin (), needle.end ());      \
+    for ( i = 0; i < NUM_TRIES; ++i ) {                     \
+        res = s_o ( haystack.begin (), haystack.end ());    \
+        if ( res != exp ) {                                 \
+            std::cout << "On run # " << i << " expected "   \
+            << exp.first - haystack.begin () << " got "           \
+            << res.first - haystack.begin () << std::endl;        \
+            throw std::runtime_error                        \
+            ( "Unexpected result from " #obj " object" );   \
+            }                                               \
+        }                                                   \
+    eTime = std::clock ();                                  \
+    printRes ( #obj " object", eTime - bTime, refDiff ); }
+    
+
+namespace {
+
+    vec ReadFromFile ( const char *name ) {
+        std::ifstream in ( name, std::ios_base::binary | std::ios_base::in );
+        std::string temp;
+        vec retVal;
+        while ( std::getline ( in, temp ))
+            retVal.push_back ( temp );
+        
+        return retVal;
+        }
+    
+    void printRes ( const char *prompt, unsigned long diff, unsigned long stdDiff ) {
+        std::cout 
+            << std::setw(34) << prompt << " "
+            << std::setw(6)  << (  1.0 * diff) / CLOCKS_PER_SEC << " seconds\t"
+            << std::setw(5)  << (100.0 * diff) / stdDiff << "% \t" 
+            << std::setw(12) << diff;
+        if ( diff > stdDiff ) 
+            std::cout << " !!";
+        std::cout << std::endl;
+        }
+    
+    void check_one ( const vec &haystack, const vec &needle, int expected ) {
+        std::size_t i;
+        std::clock_t sTime;
+        unsigned long stdDiff;
+        
+        std::pair<vec::const_iterator, vec::const_iterator> res;
+        std::pair<vec::const_iterator, vec::const_iterator> exp;        // the expected result
+        vec::const_iterator exp_start;
+        
+        if ( expected >= 0 )
+            exp_start = haystack.begin () + expected;
+        else if ( expected == -1 )
+            exp_start = haystack.end ();      // we didn't find it1
+        else if ( expected == -2 )
+            exp_start = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        else    
+            throw std::logic_error ( "Expected must be -2, -1, or >= 0" );
+
+		if ( expected == -1 )
+			exp = std::make_pair(haystack.end(), haystack.end());
+		else
+			exp = std::make_pair(exp_start, exp_start + needle.size());
+
+        std::cout << "Pattern is " << needle.size ()   << " entries long" << std::endl;
+        std::cout << "Corpus  is " << haystack.size () << " entries long" << std::endl;
+
+    //  First, the std library search
+        sTime = std::clock ();
+        for ( i = 0; i < NUM_TRIES; ++i ) {
+            vec::const_iterator s_res = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+            if ( s_res != exp.first ) {
+                std::cout << "On run # " << i << " expected " << exp.first - haystack.begin () << " got " << s_res - haystack.begin () << std::endl;
+                throw std::runtime_error ( "Unexpected result from std::search" );
+                }
+            }
+        stdDiff = std::clock () - sTime;
+        printRes ( "std::search", stdDiff, stdDiff );
+
+        runOne    ( boyer_moore_search,          stdDiff );
+        runObject ( boyer_moore,                 stdDiff );
+        runOne    ( boyer_moore_horspool_search, stdDiff );
+        runObject ( boyer_moore_horspool,        stdDiff );
+        runOne    ( knuth_morris_pratt_search,   stdDiff );
+        runObject ( knuth_morris_pratt,          stdDiff );
+        }
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    vec c1  = ReadFromFile ( "search_test_data/0001.corpus" );
+    vec p1b = ReadFromFile ( "search_test_data/0002b.pat" );
+    vec p1e = ReadFromFile ( "search_test_data/0002e.pat" );
+    vec p1n = ReadFromFile ( "search_test_data/0002n.pat" );
+    vec p1f = ReadFromFile ( "search_test_data/0002f.pat" );
+
+    std::cout << std::ios::fixed << std::setprecision(4);
+//  std::cout << "Corpus is " << c1.size () << " entries long\n";
+    std::cout << "--- Beginning ---" << std::endl;
+    check_one ( c1, p1b, 0 );       //  Find it at position zero
+    std::cout << "---- Middle -----" << std::endl;
+    check_one ( c1, p1f, -2 );      //  Don't know answer
+    std::cout << "------ End ------" << std::endl;
+    check_one ( c1, p1e, c1.size() - p1e.size ());  
+    std::cout << "--- Not found ---" << std::endl;
+    check_one ( c1, p1n, -1 );      //  Not found
+    }

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test4.cpp

@@ -0,0 +1,123 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   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)
+
+    For more information, see http://www.boost.org
+
+    Testing the range-based interfaces
+*/
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <iostream>
+#include <fstream>
+#include <iomanip>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+typedef std::vector<std::string> vec;
+#define NUM_TRIES   100
+
+#define runOne(call, refDiff)   { \
+    res = boost::algorithm::call ( haystack, needle );  \
+    if ( res != exp ) {                                 \
+        std::cout << "Expected "                        \
+            << exp.first - haystack.begin () << " got "       \
+            << res.first - haystack.begin () << std::endl;    \
+        throw std::runtime_error                        \
+            ( "Unexpected result from " #call );        \
+        }                                               \
+    }
+    
+#define runObject(obj, refDiff) { \
+    boost::algorithm::obj <vec::const_iterator> s_o =   \
+      boost::algorithm::make_##obj  ( needle );         \
+    res = s_o ( haystack );                             \
+    if ( res != exp ) {                                 \
+        std::cout << "Expected "                        \
+        << exp.first - haystack.begin () << " got "           \
+        << res.first - haystack.begin () << std::endl;        \
+        throw std::runtime_error                        \
+        ( "Unexpected result from " #obj " object" );   \
+        }                                               \
+    }
+
+namespace {
+
+    vec ReadFromFile ( const char *name ) {
+        std::ifstream in ( name, std::ios_base::binary | std::ios_base::in );
+        std::string temp;
+        vec retVal;
+        while ( std::getline ( in, temp ))
+            retVal.push_back ( temp );
+        
+        return retVal;
+        }
+    
+    void check_one ( const vec &haystack, const vec &needle, int expected ) {
+        
+        std::pair<vec::const_iterator, vec::const_iterator> res;
+        std::pair<vec::const_iterator, vec::const_iterator> exp;        // the expected result
+        vec::const_iterator exp_start;
+        
+        if ( expected >= 0 )
+            exp_start = haystack.begin () + expected;
+        else if ( expected == -1 )
+            exp_start = haystack.end ();      // we didn't find it1
+        else if ( expected == -2 )
+            exp_start = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        else    
+            throw std::logic_error ( "Expected must be -2, -1, or >= 0" );
+
+		if ( expected == -1 )
+			exp = std::make_pair(haystack.end(), haystack.end());
+		else
+			exp = std::make_pair(exp_start, exp_start + needle.size());
+
+        std::cout << "Pattern is " << needle.size ()   << " entries long" << std::endl;
+        std::cout << "Corpus  is " << haystack.size () << " entries long" << std::endl;
+
+    //  First, the std library search
+        vec::const_iterator s_res = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        if ( s_res != exp.first ) {
+            std::cout << "Expected " << exp.first - haystack.begin () << " got " << s_res - haystack.begin () << std::endl;
+            throw std::runtime_error ( "Unexpected result from std::search" );
+            }
+
+        runOne    ( boyer_moore_search,          stdDiff );
+        runObject ( boyer_moore,                 stdDiff );
+        runOne    ( boyer_moore_horspool_search, stdDiff );
+        runObject ( boyer_moore_horspool,        stdDiff );
+        runOne    ( knuth_morris_pratt_search,   stdDiff );
+        runObject ( knuth_morris_pratt,          stdDiff );
+        }
+        
+    }
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+    vec c1  = ReadFromFile ( "search_test_data/0001.corpus" );
+    vec p1b = ReadFromFile ( "search_test_data/0002b.pat" );
+    vec p1e = ReadFromFile ( "search_test_data/0002e.pat" );
+    vec p1n = ReadFromFile ( "search_test_data/0002n.pat" );
+    vec p1f = ReadFromFile ( "search_test_data/0002f.pat" );
+
+    std::cout << std::ios::fixed << std::setprecision(4);
+//  std::cout << "Corpus is " << c1.size () << " entries long\n";
+    std::cout << "--- Beginning ---" << std::endl;
+    check_one ( c1, p1b, 0 );       //  Find it at position zero
+    std::cout << "---- Middle -----" << std::endl;
+    check_one ( c1, p1f, -2 );      //  Don't know answer
+    std::cout << "------ End ------" << std::endl;
+    check_one ( c1, p1e, c1.size() - p1e.size ());  
+    std::cout << "--- Not found ---" << std::endl;
+    check_one ( c1, p1n, -1 );      //  Not found
+    }

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0001b.pat

@@ -0,0 +1,2 @@
+TU0AKgAfhPqScHN4dnZ2e3p5e3h7eXl4dnd1dnV3enp5dnd3dHV1dHNzd3l3eHh5
+eXZ4dXd2dHNwcHFwcXBxc3h0dHN1eHVzcXV1dXV2c3h5dHV3eHVwcHF

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0001e.pat

@@ -0,0 +1,2 @@
+iBJbmMuLCBhbGwg
+cmlnaHRzIHJlc2VydmVkLgAAAAA=

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0001f.pat

@@ -0,0 +1,2 @@
+q/y9PZ3uHj5ufo6UJDQ0NFQz8+RUZBQEBAOzo6Ozs4Nz06Ojs4Ojo9PT47Ojk0
+Nzc7OjQ6NzU6OjgxMzg1OjY2NjU3NTU1Nzc3NTU1NzU

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0001n.pat

@@ -0,0 +1,2 @@
+TIzMjIyMjM0MjM1nTQzNTc3MzY1NDU2NzQ2MjEwMjU1MTQ2NzU0NDI1
+NDMyMzQxMzQ0NDU1MjU2NTc5NzU1NDc4ODY1

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0002b.pat

@@ -0,0 +1,170 @@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externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0002e.pat

@@ -0,0 +1,120 @@
+5eXl5uXk5eTl5eXl5eXm5eXl5eXl5ebl5ufl5efl5ebm5+bm5ubm5ebm5ufm5ufm
+5uXm5+bl5+bl5ufm5+bm5ebn5ufm5ubn5+bm5+bm6Ofn5+fm6Ofn5+jn5ubn6Ofn
+5+fm5+fn5+fn6Ofo5ujo5+fo5+fn6Ofo6Ojn6Ojn5+nn5+fn5+jn5+fo5+fo6Ojn
+6Ofn5+np6Ofo5ufo6Ojn6Ojn6Ojn5+no5+bn6Ofn5+fn5ufn5+fo5+fo5+fm6Obn
+6Ofn5+jo6Ofo6Ojn6Ojo6Ono6eno6ejo5+jo6Ojo6Ono6Ono5Ofo6Ono6ejo6Orp
+6ejp6enp6Ojo6Onq6Onp6ejo6eno6enp6eno6ejp6Onp6enp6unp6eno6Onp6unp
+6ejp6enq6ejp6unp6enp6Ono6eno6uno6enp6Orp6enq6uno6unp6enp6erp6Orq
+6Onq6eno6unp6unp6urp6urq6enp6urq6uno6urp6erp6erq6urp6urq6erq6uvr
+6erq6enq6ejq6urp6uvr6erq6urp6unq6unq6Orp6+nq6unp6err6unp6+rp6urp
+6ejq6erp6enp6erp6erp6eno6ujp6unq6+rq6urp6+vq6uvr6urq6urp6+rq6urr
+6+nq6unq6urq6uvr6+rq6uvr6+rq6uvq6+rr6urr6uvr6+vr6+vq6+vr6+zr6+vr
+6+zr6+rr6uvr6+rr6urq6+vr6uzr6+zs6+zs6+zr6+zs7Ovr7Ozr7O3r7Ozs7Ozs
+7e3s7ezr6+3r7Ozs7e3t7O7t7O3t7ezt7u3t7u3t7u3t7+/t7e7u7+7u7+3u7+7v
+7u7u7u7v7+/w7u/v7/Dv7+/w7+/v7u/w7+/w8O/w8PDw8PDw8PHy8PHw8PHx8PLx
+8fLx8vGVjoV7dW1kYmJYVlRVVFRWVldZW1xdYGJjZmlqbG5wcnZ3en1+gYKFh4qL
+jY6OkZKTlJaXmZqdnqGjpqipq6yur7Gxs7S0tLa2uLm5u7u9vr7AwMHCw8PDxsbI
+ycrJy8zNz8/S09PU1dfX2dnZ2dja2tra2tvb2tra2tvb29rb3Nzd3d3d3t/e3d/f
+3t/f39/f197f39/f3+Df39/e3t7e3t/f3d7d3t7e397e39/e3uDg4ODg4OHh4ODg
+4d/f3+De3uDf39/g3d7d3Nza29va2tja2tnZ2NjW1tjX1tbW1tXU1dXV1dXV1dXV
+1dXW1dTT09PS0tLS0dHS0NHR09PS09LT0tTU1NPT0tPT09TS09PT0tLR09PT09PT
+09TU1NTU1NTU1dXV1dXU1dXV1dXV1dXW1tXX2NfX19fX2djZ2dnZ2drZ2tvb2trb
+29vc29vb29vc3Nzd3N7d3d/e3d7e397f3t7e39/f3uDg3t/g4OHg4ODh4d/h4OHh
+4OHh4eHh4eHi4uLi4uLj4ePi4+Li4uPj4+Pi4uPj4+Pj4+Ti5OPj4+Xj5eTk5OTk
+5OXj5OTk5OTk5OTk5OTj5OPj4+Tk5OTj5uXl5OXl5OTl5eTl5OXl5ebl5ebk5eXl
+5ubk5OXn5ubl5eXl5uXl5+Xk5eXl5ebl5ebm5ubl5uXm5ufn5uXn5ubn5ubm5+fm
+5ubl5ubn5ufm5ufm5ujn5ubn5+fn5ufm5+jo6Ofn5ubm5+bm5+fn5ufn5+fo6Ofo
+5+bn5+jn5ujn5+fn5+fo6Ofo6Ojn6Ofo6Ofn6Ojp5ufo6Ojo6ejn6efn6eno6ejo
+6Ojo5+fn6Ojp6Ojo6ejo5+no6Ojo6Ofo5+fo6Onp6Ojn6Obn6Ofm5+fn6Ojn6Ojo
+5+jo6Ojo5+jo6Ofo6Onp6Ojo6Ojn6Ojo6Ojo6eno6ejo6enp6Ojp6ejp6unp6Onp
+6enp6Onp6Onp6eno6Ono6enp6enp6Ono6enp6OXp6Ojq6ero6unp6unp6enp6unp
+6unp6eno6enp6urq6enp6enq6unq6enp6erq6urq6unq6unp6Orp6enp6erq6erp
+6erp6urq6urq6enq6+rp6urq6unp6ujp6unq6enq6evq6unq6unq6uvq6unq6urq
+6+vp6ujq6unq6urp6unq6unp6+rq6evq6urp6unq6+rq6urq6erp6urr6+nq6urp
+6unq6+nq6erp6erq6erq6erp6urq6urq6evq6enp6enp6ero6unq6+nr6urq6+rr
+6urq6uvr6urq6+vr6+vq6+zq6+vr6+vq6urr6+rr6+vr6urr6urq6+zr6+rq6+vr
+6+vr6uzt6uvr6+vr6+vr7Ovs6+vs6+zs6+vs6+rr6+rr6+vr6+vr6+vr6+zr6+zt
+7Ozr7Ovr7Ovr6+zt6+zs7e3t7O3s7O3t7ezt7O3t7ezs7O3u7ezt7O3s7u3t7e3u
+7ezu7e3u7e/u7u3u7+3u7u/u7u/v7u/u7+/v8O/v7+/v7+/v8PDv7/Dv7+7v7/Dx
+8PDw8PDx8PHv8fHy8PHw8fDx8fHw8fHy8vLy8qOdlpGLhH56dXRycHFxcnR1d3l6
+fH+ChIeJi42PkpSWmZyfoaKmqKqrra+vsLK0s7W3uLm6vL2+wMLExcfGyMrKzczN
+zs/OztDQ0tLT09TV1tbW1dfY2NfY2dra2trc3Nzd3N7e3t7e39/f39/f4ODg4ODg
+4eHg3+Hh4eDg4OHg4ODh4uHh4OHh4uHh4eHj4eHi4OHh4uHi4eDh4eHg4eHh4eHi
+4eHg4eHg4eDi4eLg4eLj4+Li4+Li4+Hi4eLg4eHh4uHi4uLh4OHg4eDh4N/e4ODf
+4ODf397e3d/f3d7f393e3t/d3t7d3d7d3d3d3d3d3tze3d3c3tzb3d3d3Nzc3N3d
+3d3e3d3d3d3d3d3d3t7e3tze3d3e3d3e3dzf3d7e3d7d3t7d3t7e3t7e3t7e3t7f
+3eDg3+Df4N/f4ODf4N/g4N/g4ODh4OHh4eHg4eDi4eHi4OHh4uHh4uLh4eLi4uLj
+4eLj4uLj4+Lh4uPj5OLj5OLj5OPk4+Tk4uPj4+Tj4+Ti5OPk4+Pj5OTl5OXj5OTj
+5OPk4+Tk5OXk5eXl5eXl5ubm5eXl5eXm5uXk5eTl5ubl5eXk5Obl5eTj5OXl5OTl
+5uXm5ubl4+bl5uXl5ebk5uXl5eXm5uTm5ubn5ubm5uXn5ubm5ufl5ebm5uXm5+Xm
+5ufm5+fm5ebm5ubn5ujn5ubl5ubn5ufn5ufn5+fn6Ojn5+fn5+jn5+fm5ufm5+fo
+5+fn5+nn5ufn5+bm6Ofm6Ojn5+jo6ejn6Ofp6Ojo5+jo6ejo6Ojn5+jp6ejo6Ojo
+6eno6Ojo6Onp6efn6ejo6Ojo6ejo6enp6Ojo6ejo6eno6ejp6eno6ejo6Ojn6Ono
+6Ojp6enp6Ojp5+fo6Ojn6Ojo6ejo6ejo6enp6Ofo6ejo6ejp6Ojo6eno6ejp6erp
+6Ono6Ojo6eno6eno6enq6erp6uno6ero6Orp6unp6erp6unq6unq6urp6uno6ero
+6Orp5eno6erq6urp6unp6erp6Onr6erp6+nq6unq6enq6+nq6urp6urq6erp6urp
+6urq6urq6urq6urq6+rp6+rq6uvq6Orq6unr6urs6urr6urp6unq6urq6urq6+rq
+6erp6urp6urq6urq6urq6err6err6+rq6+rr6urq6+rr6urr6urq6+vq6uvq6+zq
+6urr6uvr6+vq6+rr6urr6uvq6uvq6uvq6+vr6urq6err6evq6uvr6urr6urp6urq
+6+rq6unp6urq6urq6urq6uvq6urq6+vr6+vr6+vr6uvs7Ovr6+rq6+vq6+vq6+vq
+6+vq6+vr6urr6+zq6uzr6+zr6uvs6uvs6+zr6+zr6+zs6+vr6uzs7Ozs6+vq6+zr
+6+zs6+zr6+zs6+zs7Ovr7Ovs7Ovs7Ozs7Ozs7Ozs7O3s7Ozs7Ozt7O3s7Ozs7u3t
+7e3t7O3t7e3t7e3t7u3u7e3u7e3t7e3t7e7t7u7u7u7u7u3v7u3v7+/u7+7u7+7w
+7+7u7u/w8O7v7+/w8O/x8PDv8PDw8fHw7/Dv8fHx8fDx8fHx8fHx8fHw8fHx8vLy
+8vLxs6+qpqGcmJWRkI6Oj5CQkZOVl5mbnaCipKepq62wsrS2uLu9vsDDxMXGx8jI
+yszNzc7P0NDS0tLU1dXY2NjY2dnc3Nvc3Nzc3Nzd3d3d3t7e397e4N/f39/g4eHh
+4OLg4eHh4eHi4eLh4uDh4uHi4eLi4uPi4+Hh4ePh4uHi4+Lh4uLj4uLi4uPi4uLj
+4uPi4uLi4uLi4+Pi4uPi4uHi4uPj4uLj4uLi4uPh4eLi4uLi4+Li4+Pj4+Li4+Pj
+4uLi4uLi4uPi4+Lh4uHi4uLi4uPi4eHi4eDh4eHf4eHh4eLi4OLh4ODg4eDh4eHh
+4eDh4eDh4eLf4eHg4N/h4ODi4ODg4OHh4eDg4OHh4eDh4uDg4uHi4eLg4OHh4eDh
+4OHg4uHh4eHh4eDg4eHi4eHi4eHi4eLh4uLi4uHi4uLi4uPj4uPj4uHi5OPk4+Pj
+4+Pj4uPk5OLi5OPj4+Pk5OTi4+Pj5OPk5OPj5OPk5OPk5OTk5OXk5OTk4+Tl5eTk
+5eXk4+Tk5OTk5OXk5OXl5eXk5eXm5eXk5OXk5uXl5ebl5uXl5ubn5eXm5ubl5ubm
+5uXl5eXm5uXm5uXl5eXl5eXk5eXm5uXl5ubn5ubl5ubl5+Xm5ubm5ubn5ubn5efm
+5+fm5ubn5+fn6Ofn5+fm5ufo5ubn5+bm5+fn5+fn5+fn5+jm6Ofn5ujn5+fn5+fn
+6Ojo6Ojn6Ojn5+jo6Ofn6Ofo5+fn5+jo6Ofo5+jn5+jn5+jn5+jn6Ojo5+jo6Ono
+5+no6Ofo6Ojo6Ofp6ejn6Ojo6Onn6Onp6enp6eno6efo5+jo6Ono6Ojo6enp6Ojo
+6enp6enp6Ojq6Ojo6eno6Onp6ejp6unp6ujq6unq6enp6Ojp6Orp6Onp6enq6enq
+6eno6Onp6eno6ejp6eno6Onp6erp6ejq6eno6erp6enp6enq6urp6Onq6unp6urp
+6+nq6enp6enq6unp6erp6+nq6enp6unp6enp6erq6unr6uvq6erp6+rp6erp6unq
+6urq6urp6urq6err6uvq6urq6urp6+rq6uvr6uvq6+rp6urq6urq6uvp6+nq6urr
+6unq6+vq6+rr6urq6urq6uvq6urp6urq6urr6urq6urq6urr6+rr6urq6uvq6urr
+6uvq6erq6uvr6+rr6urr7Ovq6uvr6+vr6+vq6+vr6+rq6+rr6+vr6urq6+vr6uvq
+6uvq6+vq6+zq6uvr6+rq6uvq6+rq6urr6+vq6urq6+rq6urq6uvr6+vq6+rq6uvr
+6+zr6+vr6uvr6+vr6+vs6+vr6+vr7Ozr7Orr7evr6+rr6uvs6+vr6+rq6+zs6+vs
+7Ovs7Ozs7Ovs6+zs7Ozs7Ovs6+zs7Ovs7Ovs6+zs7O3s7Ovs7Ozr7Ozr7Ozs7Ozs
+7O3s7O3s7e3t7Ozr7Ozs7uzt7ezs7O3t7uzs7e3t7uzt7ezu7e7t7u3u7u7u7e7u
+7e7u7u/u7u/v7e/u7+7v7+/v7u/u7u/w7+/v7u/w7vHv7u/v7vDw8PDw8PHx8fHx
+8PDw8fDx8PLx8vLx8fDw8fHy8vLy8vLy8/MAEAEAAAMAAAABBJcAAAEBAAMAAAAB
+Bt4AAAECAAMAAAABAAgAAAEDAAMAAAABAAEAAAEGAAMAAAABAAEAAAERAAQAAAAQ
+AB+FwAESAAMAAAABAAEAAAEVAAMAAAABAAEAAAEWAAMAAAABAG8AAAEXAAQAAAAQ
+AB+GAAEaAAUAAAABAB+GQAEbAAUAAAABAB+GSAEcAAMAAAABAAEAAAEoAAMAAAAB
+AAIAAAFTAAMAAAABAAEAAIdzAAcAAASkAB+GUAAAAAAAAAAIAAH9gQAD+voABfhz
+AAf17AAJ82UAC/DeAA3uVwAP69AAEelJABPmwgAV5DsAF+G0ABnfLQAb3KYAHdof
+AAH9eQAB/XkAAf15AAH9eQAB/XkAAf15AAH9eQAB/XkAAf15AAH9eQAB/XkAAf15
+AAH9eQAB/XkAAf15AAGq2yWAAAAAIAAAJYAAAAAgAAAAAASkYXBwbAIgAABzY25y
+R1JBWVhZWiAH0wAHAAEAAAAAAABhY3NwQVBQTAAAAABub25lAAAAAAAAAAAAAAAA
+AAAAAAAA9tYAAQAAAADTLWFwcGyYcjd2/nI/x5EwPxA3BfUzAAAAAAAAAAAAAAAA
+AAAAAAAAAAAAAAAAAAAAAAAAAAVkZXNjAAAA5AAAAEF3dHB0AAAAwAAAABRrVFJD
+AAAA1AAAAA5jcHJ0AAAEYAAAAEFkc2NtAAABKAAAAzZYWVogAAAAAAAA81EAAQAA
+AAEWzGN1cnYAAAAAAAAAAQHNAABkZXNjAAAAAAAAABVTY2FubmVyIEdyYXkgUHJv
+ZmlsZQAAAAAAAAAAAAAAFVNjYW5uZXIgR3JheSBQcm9maWxlAAAAAG1sdWMAAAAA
+AAAADwAAAAxlblVTAAAAKAAAAw5lc0VTAAAAMAAAAYpkYURLAAAAPAAAAjZkZURF
+AAAAOgAAAeJmaUZJAAAAMgAAAMRmckZVAAAALgAAATBpdElUAAAALAAAAuJubE5M
+AAAAKAAAAnJub05PAAAAKAAAAbpwdEJSAAAALgAAArRzdlNFAAAAOgAAAPZqYUpQ
+AAAAGgAAAV5rb0tSAAAAGgAAApp6aFRXAAAAEgAAAXh6aENOAAAAGgAAAhwAUwBr
+AGEAbgBuAGUAcgBpAG4AIABIAGEAcgBtAGEAYQAtAHAAcgBvAGYAaQBpAGwAaQBH
+AHIA5QBzAGsAYQBsAGUAcAByAG8AZgBpAGwAIABmAPYAcgAgAEIAaQBsAGQAbADk
+AHMAYQByAGUAUAByAG8AZgBpAGwAIABHAHIAaQBzACAAZAB1ACAAUwBjAGEAbgBu
+AGUAdQByMLkwrTDjMMowsDDsMKQw1zDtMNUwoTCkMOtjg2PPVmhwcJaOgnJfaWPP
+j/AAUABlAHIAZgBpAGwAIABHAHIAaQBzACAAcABhAHIAYQAgAEUAcwBjAOEAbgBl
+AHIARwByAOUAdABvAG4AZQBzAGsAYQBuAG4AZQByAHAAcgBvAGYAaQBsAEcAcgBh
+AHUAcwB0AHUAZgBlAG4ALQBQAHIAbwBmAGkAbAAgAGYA/AByACAAUwBjAGEAbgBu
+AGUAcmJrY89O6gAgAEcAcgBhAHkAIGPPj/Blh072AEcAcgDlAHQAbwBuAGUAYgBl
+AHMAawByAGkAdgBlAGwAcwBlACAAdABpAGwAIABTAGMAYQBuAG4AZQByAEcAcgBp
+AGoAcwBwAHIAbwBmAGkAZQBsACAAUwBjAGEAbgBuAGUAcsKkzpCxCAAgAEcAcgBh
+AHkAINUEuFzTDMd8AFAAZQByAGYAaQBsACAAQwBpAG4AegBhACAAZABlACAAUwBj
+AGEAbgBuAGUAcgBQAHIAbwBmAGkAbABvACAARwByAGkAZwBpAG8AIABTAGMAYQBu
+AG4AZQByAFMAYwBhAG4AbgBlAHIAIABHAHIAYQB5ACAAUAByAG8AZgBpAGwAZQAA
+dGV4dAAAAABDb3B5cmlnaHQgMjAwMyBBcHBsZSBDb21wdXRlciBJbmMuLCBhbGwg
+cmlnaHRzIHJlc2VydmVkLgAAAAA=

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0002f.pat

@@ -0,0 +1,136 @@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externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/search_test_data/0002n.pat

@@ -0,0 +1,136 @@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*SUVNUU1JOTlBPUFBQU1RSUVBSUVNSUVNR
+UVNVVFRTVVRWVFJTVlhXWVdXU1NTWFtbWl5dXFlZWFhZWFxYVlpYWFlbWVpZWVZX
+V1dYWVhYWFdXVVRZW1pZWlxdW1peXl1cXGBgX19gYV9fW1pZW1lcW1hWVFVXVVlW
+U1NVaoS8ytPa3uLk5+jo6el4eXh1eXh9eHt7e3t4eHZ1eHh0cm5jWEtLTEY/PTs8
+P0NGSklGREVBOz0+RD9BRENAPkE/Oj0+P0A9Pz0+Q0NCQkRJSUlKSUtMTEpLTFBU
+VlVUVlZSWVteXFpYU1RXWFlVWFlXV1VTVVJPUlZaVldTUVJRUVFOUE1KTE1LSElF
+QUVEQkVCRUNERD8/Pjs8QDw6Ojo6Ozw5Nzk5PDc2NDQ4Ojg6OTk4Ojc4PEQ7Oj0/
+PUNCRkNBSUtHSERJTEdKR1BLUVlVV1ZiV1BLU1JVVVZWU1RbWVBJQzo9NzY3NzYy
+Mjc3ODg0MzU3OTk/Pjo8Oz1ERk9FRkVJSklXUkxWUVBRSlFPV1ZHTU9SXlVdVVdc
+VlZMUk1QWVJRUFNZWF5eWU9PU1VWVFRSWFBPVllbWlZYWVdUVFFYXFhTUkxKQTo0
+MjQ1OT5DVFhPV1paYFtgX15gX1FPUlRUWltbVlNPUVdWUlhXXVZVVldaVlNWVllZ
+VFNPTVNRTVFPUlNUUVVUUlhVU1ZRS0lLRk1LSFFPTVFNTUpLT01LUlRMTVNVU1BU
+V1tiWFVQSUNDQEVDSEhHVVJYWlBYXn6Ypqiil4qBfHp4cGttcHNtYFBDOz47Ojo3
+OT07ODo7Oz88OjxAREA8Pj07OjxBQTw4PUFEQTxAPTtBRUVGR0U+QEI+ODUzMzc2
+Njc4ODQxNDY3OTs8P0RKR0hSTlVfVVtRT09RU1VSUVJTU1JQS05OTVJXVVZUUVNY
+VVRSTUxOSUtMSktKTEpJTEpKRkdLTE1NT01NSklJSktOTkpGREdGQUFERUREREI9
+Pj4/Ozc5ODo5Njc6OTs5NzpBSlhja21vb3RxcHBucnp9eXl6fH+EhIWGjo2Njo+N
+j4+MiYuLhH54cm5tb3BzfYaLjo6MjpKSkpORlJeWkpCHfnNrYVdWVVRMQj0/RE9V
+UVJQUVFRVFtcXF1dXFlWVlZXV1FRTk9NS0VDQ0FBQUFAP0FER0dHR0dHSUhKSkxL
+TEpJTlJOUFFUVlNWVltcYGBfZGhnaW5wcnR2dXh6eXt8f4GBgoKAg4GBgoODgoSE
+iIiHio6Ni4+Sk46KjY6Qk5WVkpGUlJOSlpKSlJWTkpOYmJiYmZial5iZm5mZmpye
+nZ+foKGip7Cyt7e5vLyznpKcn5aVorO5wcC/wLm2sa2rrK+zuLa4uL2/v768vMDA
+wsG+wL68vra1tLK1tri8vbi6ubi2tre3tra1tbW4trGroY1tW1hUVFNNTk5KSktP
+T0tLSkpMSktNTExLS0tLSkxKSUlMTUtLSk5JSE1OTk9MTE9RT0xNUFBRU1BPTU1P
+UFBTUlFPUlFOUVNRUFFRUU9OUFFTU1NTUlNUVFJTUU5QUlJUVVRUU1ZST1BPUFFS
+UVBOUVJPUFJSUFJRU1NRUFFSVFNSVFNUVFFRU1RXVlVXVFlYWFhZWFhVWFZUWFdX
+XV1cWFdYWVdaWFdaVVVaWVlaWVdaWVlYVVdaWVlXWFlbWFdYWVpdW1xcXlpbX2Fj
+YmBhYV9fX15cXl9aWFlVUFZWV1lYWVlXU1V#orzJ0tre4eTm5+jq6nl3d3l4d3h6
+ent8fHh2dXN1d3NxbGFUSkdGSEM7Pj89QUhJRkZFQ0RFQ0JCQj09PTg8PUE7Oj4+
+Qz0/QEFDQkVHR0pJSUxLTU1MTExLT1FSVFNTVVRVWFdXV1ZRUlNWVlVXWFlXWlta
+VFZXWlxZV1VTVVBTUU1NTEtNS05MR0pMSEVER0ZISEVERD4+Ozs6Ozs6OTk6Ojc1
+NTY5ODY2Njg2NzY4ODk3PDo4Pjw8PD9CRUFBPT5GRkVLTEZLTVFKSkxSW1daV11Z
+SlJWVlNSV1pUU1dXVlZQQjo7OTU1NDMyNjc0NTZINzc3OTo8PT07QUJDUkpOS0hN
+R1RRTlRQTlFIUFJVVEhSUVJgV1ZSWmFeYFJVTk5VUlJQV1lUVVZQSk5OUVZYVFBP
+UFNUWV1XUlRZWFlXVFVcXlpWWFBCOTIyMzc2PUNNV01TWlpbW1paXl1VVFZXVVZZ
+V1lcUk1OU1BVXVlaVlNTUVNYVVVbUk9VT05JTE9SUU9QUVZVUlNVWFlUS05LTFFU
+V09SUFNSUVRNSkpNUk5OV1FNVFpSTlRcYVxYW1FKQ0JER0NFR0hTTFFUTlVWbYma
+paOelImBfXx7dnRxcXBpWkY9Oj1COTQ5Ozs7QTk6Pzw7Ozs/QEJDPDo6PkBFPjtA
+QkRFQjk6PUJGREZEQkFCRj04MzQ1ODk1NTM5NzQ0NTk6Oj49P0JFSFRRWFlSXFNS
+VlZXVVRTU1ZTUFNNTU5PUFRUV1lRTk5SU09MTU5PUVBKS01MSkhIS0pJR0hDR0tL
+TUtFSk1OS0tIR0VHRkhEQ0NGRENBPj89PT87PDs4Ojw4OTo4Njk9QUxZZG1vb3By
+cnFzcnR2fH99eHh7gISHjJKJjpGRk5WSkpKOiomIgHx0cm5vcXV+hIeLjo+SlZiY
+mJWUlZmSjIJ4cG1jVE5NTkxIQ0ZMVFhXVldUVldYXWBiX19gXFxbWlhXU1FPTk1L

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/sort_subrange_test.cpp

@@ -0,0 +1,151 @@
+#include <boost/config.hpp>
+#include <boost/algorithm/sort_subrange.hpp>
+#include <boost/algorithm/cxx11/is_sorted.hpp>
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+#include <vector>
+#include <iostream>
+
+#if (__cplusplus >= 201103L) || defined(BOOST_NO_CXX98_RANDOM_SHUFFLE)
+#include <random>
+
+std::default_random_engine gen;
+template<typename RandomIt>
+void do_shuffle(RandomIt first, RandomIt last)
+{ std::shuffle(first, last, gen); }
+#else
+template<typename RandomIt>
+void do_shuffle(RandomIt first, RandomIt last)
+{ std::random_shuffle(first, last); }
+#endif
+
+namespace ba = boost::algorithm;
+
+template <typename Iter>
+void check_sequence ( Iter first, Iter last, Iter sf, Iter sl )
+{
+	if (sf == sl) return;
+	for (Iter i = first; i < sf; ++i)
+		BOOST_CHECK(*i < *sf);
+	BOOST_CHECK(ba::is_sorted(sf, sl));
+	for (Iter i = sl; i < last; ++i)
+		BOOST_CHECK(*(sl-1) < *i);
+}
+
+template <typename Iter, typename Pred>
+void check_sequence ( Iter first, Iter last, Iter sf, Iter sl, Pred p )
+{
+	if (sf == sl) return;
+	for (Iter i = first; i < sf; ++i)
+		BOOST_CHECK(p(*i, *sf));
+	BOOST_CHECK(ba::is_sorted(sf, sl, p));
+	for (Iter i = sl; i < last; ++i)
+		BOOST_CHECK(p(*(sl-1), *i));
+
+}
+
+// 	for ( int i = 0; i < v.size(); ++i )
+// 		std::cout << v[i] << ' ';
+// 	std::cout << std::endl;
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+	{
+	std::vector<int> v;
+	for ( int i = 0; i < 10; ++i )
+		v.push_back(i);
+
+	const std::vector<int>::iterator b = v.begin();
+	ba::sort_subrange(b, v.end(), b + 3, b + 6);
+	check_sequence   (b, v.end(), b + 3, b + 6);
+
+	BOOST_CHECK_EQUAL(v[3], 3);
+	BOOST_CHECK_EQUAL(v[4], 4);
+	BOOST_CHECK_EQUAL(v[5], 5);
+
+//	Mix them up and try again - single element
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b + 7, b + 8);
+	check_sequence   (b, v.end(), b + 7, b + 8);
+
+	BOOST_CHECK_EQUAL(v[7], 7);
+
+//	Mix them up and try again - at the end
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b + 7, v.end());
+	check_sequence   (b, v.end(), b + 7, v.end());
+
+	BOOST_CHECK_EQUAL(v[7], 7);
+	BOOST_CHECK_EQUAL(v[8], 8);
+	BOOST_CHECK_EQUAL(v[9], 9);
+
+//	Mix them up and try again - at the beginning
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, b + 2);
+	check_sequence   (b, v.end(), b, b + 2);
+
+	BOOST_CHECK_EQUAL(v[0], 0);
+	BOOST_CHECK_EQUAL(v[1], 1);
+
+//	Mix them up and try again - empty subrange
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, b);
+	check_sequence   (b, v.end(), b, b);
+
+//	Mix them up and try again - entire subrange
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, v.end());
+	check_sequence   (b, v.end(), b, v.end());
+	}
+
+	{
+	std::vector<int> v;
+	for ( int i = 0; i < 10; ++i )
+		v.push_back(i);
+
+	const std::vector<int>::iterator b = v.begin();
+	ba::sort_subrange(b, v.end(), b + 3, b + 6, std::greater<int>());
+	check_sequence   (b, v.end(), b + 3, b + 6, std::greater<int>());
+
+	BOOST_CHECK_EQUAL(v[3], 6);
+	BOOST_CHECK_EQUAL(v[4], 5);
+	BOOST_CHECK_EQUAL(v[5], 4);
+
+//	Mix them up and try again - single element
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b + 7, b + 8, std::greater<int>());
+	check_sequence   (b, v.end(), b + 7, b + 8, std::greater<int>());
+
+	BOOST_CHECK_EQUAL(v[7], 2);
+
+//	Mix them up and try again - at the end
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b + 7, v.end(), std::greater<int>());
+	check_sequence   (b, v.end(), b + 7, v.end(), std::greater<int>());
+
+	BOOST_CHECK_EQUAL(v[7], 2);
+	BOOST_CHECK_EQUAL(v[8], 1);
+	BOOST_CHECK_EQUAL(v[9], 0);
+
+//	Mix them up and try again - at the beginning
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, b + 2, std::greater<int>());
+	check_sequence   (b, v.end(), b, b + 2, std::greater<int>());
+
+	BOOST_CHECK_EQUAL(v[0], 9);
+	BOOST_CHECK_EQUAL(v[1], 8);
+
+//	Mix them up and try again - empty subrange
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, b, std::greater<int>());
+	check_sequence   (b, v.end(), b, b, std::greater<int>());
+
+//	Mix them up and try again - entire subrange
+	do_shuffle(v.begin(), v.end());
+	ba::sort_subrange(b, v.end(), b, v.end(), std::greater<int>());
+	check_sequence   (b, v.end(), b, v.end(), std::greater<int>());
+	}
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/transform_exclusive_scan_test.cpp

@@ -0,0 +1,137 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+#include <numeric>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/iota.hpp>
+#include <boost/algorithm/cxx17/transform_exclusive_scan.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+int triangle(int n) { return n*(n+1)/2; }
+
+template <class _Tp>
+struct identity
+{
+    const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+
+template <class Iter1, class BOp, class UOp, class T, class Iter2>
+void
+test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+//  Test not in-place
+    ba::transform_exclusive_scan(first, last, std::back_inserter(v), init, bop, uop);
+    BOOST_CHECK(std::distance(rFirst, rLast) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+
+//  Test in-place
+    v.clear();
+    v.assign(first, last);
+    ba::transform_exclusive_scan(v.begin(), v.end(), v.begin(), init, bop, uop);
+    BOOST_CHECK(std::distance(rFirst, rLast) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+}
+
+
+template <class Iter>
+void
+test()
+{
+          int ia[]     = { 1,  3,  5,   7,   9};
+    const int pResI0[] = { 0,  1,  4,   9,  16};        // with identity
+    const int mResI0[] = { 0,  0,  0,   0,   0};
+    const int pResN0[] = { 0, -1, -4,  -9, -16};        // with negate
+    const int mResN0[] = { 0,  0,  0,   0,   0};
+    const int pResI2[] = { 2,  3,  6,  11,  18};        // with identity
+    const int mResI2[] = { 2,  2,  6,  30, 210};
+    const int pResN2[] = { 2,  1, -2,  -7, -14};        // with negate
+    const int mResN2[] = { 2, -2,  6, -30, 210};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    BOOST_CHECK(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i ) {
+        test(Iter(ia), Iter(ia + i), std::plus<int>(),       identity<int>(),    0, pResI0, pResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(),    0, mResI0, mResI0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<int>(),       std::negate<int>(), 0, pResN0, pResN0 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 0, mResN0, mResN0 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<int>(),       identity<int>(),    2, pResI2, pResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(),    2, mResI2, mResI2 + i);
+        test(Iter(ia), Iter(ia + i), std::plus<int>(),       std::negate<int>(), 2, pResN2, pResN2 + i);
+        test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 2, mResN2, mResN2 + i);
+        }
+}
+
+void basic_tests()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 50, std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 50 + (int) i * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 30, std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 30 + triangle(i-1));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::transform_exclusive_scan(v.begin(), v.end(), v.begin(), 40, std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 40 + triangle(i));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::transform_exclusive_scan(v.begin(), v.end(), std::back_inserter(res), 40, std::plus<int>(), identity<int>());
+    BOOST_CHECK(res.empty());
+    }
+}
+
+
+void test_transform_exclusive_scan_init()
+{
+	basic_tests();
+//  All the iterator categories
+    test<input_iterator        <const int*> >();
+    test<forward_iterator      <const int*> >();
+    test<bidirectional_iterator<const int*> >();
+    test<random_access_iterator<const int*> >();
+    test<const int*>();
+    test<      int*>();
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_transform_exclusive_scan_init();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/transform_inclusive_scan_test.cpp

@@ -0,0 +1,233 @@
+/*
+   Copyright (c) Marshall Clow 2017.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <vector>
+#include <functional>
+#include <numeric>
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx11/iota.hpp>
+#include <boost/algorithm/cxx17/transform_inclusive_scan.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+int triangle(int n) { return n*(n+1)/2; }
+
+template <class _Tp>
+struct identity
+{
+    const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+
+template <class Iter1, class BOp, class UOp, class Iter2>
+void
+transform_inclusive_scan_test(Iter1 first, Iter1 last, BOp bop, UOp uop, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+//  Test not in-place
+    ba::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop);
+    BOOST_CHECK(std::distance(first, last) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+
+//  Test in-place
+    v.clear();
+    v.assign(first, last);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop);
+    BOOST_CHECK(std::distance(first, last) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+}
+
+
+template <class Iter>
+void
+transform_inclusive_scan_test()
+{
+          int ia[]     = {  1,  3,   5,   7,    9};
+    const int pResI0[] = {  1,  4,   9,  16,   25};        // with identity
+    const int mResI0[] = {  1,  3,  15, 105,  945};
+    const int pResN0[] = { -1, -4,  -9, -16,  -25};        // with negate
+    const int mResN0[] = { -1,  3, -15, 105, -945};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    BOOST_CHECK(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i ) {
+        transform_inclusive_scan_test(Iter(ia), Iter(ia + i), std::plus<int>(),       identity<int>(),    pResI0, pResI0 + i);
+        transform_inclusive_scan_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(),    mResI0, mResI0 + i);
+        transform_inclusive_scan_test(Iter(ia), Iter(ia + i), std::plus<int>(),       std::negate<int>(), pResN0, pResN0 + i);
+        transform_inclusive_scan_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), mResN0, mResN0 + i);
+        }
+}
+
+
+//  Basic sanity
+void basic_transform_inclusive_scan_tests()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == (int)(i+1) * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == triangle(i));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>());
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == triangle(i + 1));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<int>(), identity<int>());
+    BOOST_CHECK(res.empty());
+    }
+}
+
+void test_transform_inclusive_scan()
+{
+    basic_transform_inclusive_scan_tests();
+
+//  All the iterator categories
+    transform_inclusive_scan_test<input_iterator        <const int*> >();
+    transform_inclusive_scan_test<forward_iterator      <const int*> >();
+    transform_inclusive_scan_test<bidirectional_iterator<const int*> >();
+    transform_inclusive_scan_test<random_access_iterator<const int*> >();
+    transform_inclusive_scan_test<const int*>();
+    transform_inclusive_scan_test<      int*>();
+}
+
+
+template <class Iter1, class BOp, class UOp, class T, class Iter2>
+void
+transform_inclusive_scan_init_test(Iter1 first, Iter1 last, BOp bop, UOp uop, T init, Iter2 rFirst, Iter2 rLast)
+{
+    std::vector<typename std::iterator_traits<Iter1>::value_type> v;
+//  Test not in-place
+    ba::transform_inclusive_scan(first, last, std::back_inserter(v), bop, uop, init);
+    BOOST_CHECK(std::distance(rFirst, rLast) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+
+//  Test in-place
+    v.clear();
+    v.assign(first, last);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), bop, uop, init);
+    BOOST_CHECK(std::distance(rFirst, rLast) == v.size());
+    BOOST_CHECK(std::equal(v.begin(), v.end(), rFirst));
+}
+
+
+template <class Iter>
+void
+transform_inclusive_scan_init_test()
+{
+          int ia[]     = {  1,  3,   5,    7,     9};
+    const int pResI0[] = {  1,  4,   9,   16,    25};        // with identity
+    const int mResI0[] = {  0,  0,   0,    0,     0};
+    const int pResN0[] = { -1, -4,  -9,  -16,   -25};        // with negate
+    const int mResN0[] = {  0,  0,   0,    0,     0};
+    const int pResI2[] = {  3,  6,  11,   18,    27};        // with identity
+    const int mResI2[] = {  2,  6,  30,  210,  1890};
+    const int pResN2[] = {  1, -2,  -7,  -14,   -23};        // with negate
+    const int mResN2[] = { -2,  6, -30,  210, -1890};
+    const unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    BOOST_CHECK(sa == sizeof(pResI0) / sizeof(pResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResI0) / sizeof(mResI0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResN0) / sizeof(pResN0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResN0) / sizeof(mResN0[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResI2) / sizeof(pResI2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResI2) / sizeof(mResI2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(pResN2) / sizeof(pResN2[0]));       // just to be sure
+    BOOST_CHECK(sa == sizeof(mResN2) / sizeof(mResN2[0]));       // just to be sure
+
+    for (unsigned int i = 0; i < sa; ++i ) {
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::plus<int>(),       identity<int>(),    0, pResI0, pResI0 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(),    0, mResI0, mResI0 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::plus<int>(),       std::negate<int>(), 0, pResN0, pResN0 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 0, mResN0, mResN0 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::plus<int>(),       identity<int>(),    2, pResI2, pResI2 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), identity<int>(),    2, mResI2, mResI2 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::plus<int>(),       std::negate<int>(), 2, pResN2, pResN2 + i);
+        transform_inclusive_scan_init_test(Iter(ia), Iter(ia + i), std::multiplies<int>(), std::negate<int>(), 2, mResN2, mResN2 + i);
+        }
+}
+
+
+//  Basic sanity
+void basic_transform_inclusive_scan_init_tests()
+{
+    {
+    std::vector<int> v(10);
+    std::fill(v.begin(), v.end(), 3);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>(), 50);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 50 + (int) (i + 1) * 3);
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 0);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>(), 30);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 30 + triangle(i));
+    }
+
+    {
+    std::vector<int> v(10);
+    ba::iota(v.begin(), v.end(), 1);
+    ba::transform_inclusive_scan(v.begin(), v.end(), v.begin(), std::plus<int>(), identity<int>(), 40);
+    for (size_t i = 0; i < v.size(); ++i)
+        BOOST_CHECK(v[i] == 40 + triangle(i + 1));
+    }
+
+    {
+    std::vector<int> v, res;
+    ba::transform_inclusive_scan(v.begin(), v.end(), std::back_inserter(res), std::plus<int>(), identity<int>(), 1);
+    BOOST_CHECK(res.empty());
+    }
+}
+
+void test_transform_inclusive_scan_init()
+{
+	basic_transform_inclusive_scan_init_tests();
+
+//  All the iterator categories
+    transform_inclusive_scan_init_test<input_iterator        <const int*> >();
+    transform_inclusive_scan_init_test<forward_iterator      <const int*> >();
+    transform_inclusive_scan_init_test<bidirectional_iterator<const int*> >();
+    transform_inclusive_scan_init_test<random_access_iterator<const int*> >();
+    transform_inclusive_scan_init_test<const int*>();
+    transform_inclusive_scan_init_test<      int*>();
+
+}
+
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_transform_inclusive_scan();
+  test_transform_inclusive_scan_init();
+}

externals/vcpkg/buildtrees/boost-algorithm/src/ost-1.79.0-9729234016.clean/test/transform_reduce_test.cpp

@@ -0,0 +1,188 @@
+/*
+   Copyright (c) Marshall Clow 2013.
+
+   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)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/cxx17/transform_reduce.hpp>
+
+#include "iterator_test.hpp"
+
+#define BOOST_TEST_MAIN
+#include <boost/test/unit_test.hpp>
+
+namespace ba = boost::algorithm;
+
+template <class _Tp>
+struct identity
+{
+    const _Tp& operator()(const _Tp& __x) const { return __x;}
+};
+
+template <class _Tp>
+struct twice
+{
+  	const _Tp operator()(const _Tp& __x) const { return 2 * __x; }
+};
+
+
+template <class Iter1, class T, class BOp, class UOp>
+void
+test_init_bop_uop(Iter1 first1, Iter1 last1, T init, BOp bOp, UOp uOp, T x)
+{
+    BOOST_CHECK(ba::transform_reduce(first1, last1, init, bOp, uOp) == x);
+}
+
+template <class Iter>
+void
+test_init_bop_uop()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+
+    test_init_bop_uop(Iter(ia), Iter(ia),    0, std::plus<int>(),       identity<int>(),       0);
+    test_init_bop_uop(Iter(ia), Iter(ia),    1, std::multiplies<int>(), identity<int>(),       1);
+    test_init_bop_uop(Iter(ia), Iter(ia+1),  0, std::multiplies<int>(), identity<int>(),       0);
+    test_init_bop_uop(Iter(ia), Iter(ia+1),  2, std::plus<int>(),       identity<int>(),       3);
+    test_init_bop_uop(Iter(ia), Iter(ia+2),  0, std::plus<int>(),       identity<int>(),       3);
+    test_init_bop_uop(Iter(ia), Iter(ia+2),  3, std::multiplies<int>(), identity<int>(),       6);
+    test_init_bop_uop(Iter(ia), Iter(ia+sa), 4, std::multiplies<int>(), identity<int>(),    2880);
+    test_init_bop_uop(Iter(ia), Iter(ia+sa), 4, std::plus<int>(),       identity<int>(),      25);
+
+    test_init_bop_uop(Iter(ia), Iter(ia),    0, std::plus<int>(),       twice<int>(),       0);
+    test_init_bop_uop(Iter(ia), Iter(ia),    1, std::multiplies<int>(), twice<int>(),       1);
+    test_init_bop_uop(Iter(ia), Iter(ia+1),  0, std::multiplies<int>(), twice<int>(),       0);
+    test_init_bop_uop(Iter(ia), Iter(ia+1),  2, std::plus<int>(),       twice<int>(),       4);
+    test_init_bop_uop(Iter(ia), Iter(ia+2),  0, std::plus<int>(),       twice<int>(),       6);
+    test_init_bop_uop(Iter(ia), Iter(ia+2),  3, std::multiplies<int>(), twice<int>(),      24);
+    test_init_bop_uop(Iter(ia), Iter(ia+sa), 4, std::multiplies<int>(), twice<int>(),  184320); // 64 * 2880
+    test_init_bop_uop(Iter(ia), Iter(ia+sa), 4, std::plus<int>(),       twice<int>(),      46);
+}
+
+void test_transform_reduce_init_bop_uop()
+{
+	BOOST_CHECK ( true );
+}
+
+template <class Iter1, class Iter2, class T, class Op1, class Op2>
+void
+test_init_bop_bop(Iter1 first1, Iter1 last1, Iter2 first2, T init, Op1 op1, Op2 op2, T x)
+{
+    BOOST_CHECK(ba::transform_reduce(first1, last1, first2, init, op1, op2) == x);
+}
+
+template <class SIter, class UIter>
+void
+test_init_bop_bop()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned int ua[] = {2, 4, 6, 8, 10,12};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    BOOST_CHECK(sa == sizeof(ua) / sizeof(ua[0]));       // just to be sure
+
+    test_init_bop_bop(SIter(ia), SIter(ia),    UIter(ua), 0, std::plus<int>(), std::multiplies<int>(),       0);
+    test_init_bop_bop(UIter(ua), UIter(ua),    SIter(ia), 1, std::multiplies<int>(), std::plus<int>(),       1);
+    test_init_bop_bop(SIter(ia), SIter(ia+1),  UIter(ua), 0, std::multiplies<int>(), std::plus<int>(),       0);
+    test_init_bop_bop(UIter(ua), UIter(ua+1),  SIter(ia), 2, std::plus<int>(), std::multiplies<int>(),       4);
+    test_init_bop_bop(SIter(ia), SIter(ia+2),  UIter(ua), 0, std::plus<int>(), std::multiplies<int>(),      10);
+    test_init_bop_bop(UIter(ua), UIter(ua+2),  SIter(ia), 3, std::multiplies<int>(), std::plus<int>(),      54);
+    test_init_bop_bop(SIter(ia), SIter(ia+sa), UIter(ua), 4, std::multiplies<int>(), std::plus<int>(), 2099520);
+    test_init_bop_bop(UIter(ua), UIter(ua+sa), SIter(ia), 4, std::plus<int>(), std::multiplies<int>(),     186);
+}
+
+void test_transform_reduce_init_bop_bop()
+{
+//  All the iterator categories
+    test_init_bop_bop<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
+    test_init_bop_bop<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
+    test_init_bop_bop<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init_bop_bop<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init_bop_bop<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
+    test_init_bop_bop<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
+    test_init_bop_bop<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init_bop_bop<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init_bop_bop<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test_init_bop_bop<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test_init_bop_bop<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init_bop_bop<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init_bop_bop<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test_init_bop_bop<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test_init_bop_bop<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init_bop_bop<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+//  just plain pointers (const vs. non-const, too)
+    test_init_bop_bop<const int*, const unsigned int *>();
+    test_init_bop_bop<const int*,       unsigned int *>();
+    test_init_bop_bop<      int*, const unsigned int *>();
+    test_init_bop_bop<      int*,       unsigned int *>();
+}
+
+template <class Iter1, class Iter2, class T>
+void
+test_init(Iter1 first1, Iter1 last1, Iter2 first2, T init, T x)
+{
+    BOOST_CHECK(ba::transform_reduce(first1, last1, first2, init) == x);
+}
+
+template <class SIter, class UIter>
+void
+test_init()
+{
+    int ia[]          = {1, 2, 3, 4, 5, 6};
+    unsigned int ua[] = {2, 4, 6, 8, 10,12};
+    unsigned sa = sizeof(ia) / sizeof(ia[0]);
+    BOOST_CHECK(sa == sizeof(ua) / sizeof(ua[0]));       // just to be sure
+
+    test_init(SIter(ia), SIter(ia),    UIter(ua), 0,   0);
+    test_init(UIter(ua), UIter(ua),    SIter(ia), 1,   1);
+    test_init(SIter(ia), SIter(ia+1),  UIter(ua), 0,   2);
+    test_init(UIter(ua), UIter(ua+1),  SIter(ia), 2,   4);
+    test_init(SIter(ia), SIter(ia+2),  UIter(ua), 0,  10);
+    test_init(UIter(ua), UIter(ua+2),  SIter(ia), 3,  13);
+    test_init(SIter(ia), SIter(ia+sa), UIter(ua), 0, 182);
+    test_init(UIter(ua), UIter(ua+sa), SIter(ia), 4, 186);
+}
+
+void test_transform_reduce_init()
+{
+//  All the iterator categories
+    test_init<input_iterator        <const int*>, input_iterator        <const unsigned int*> >();
+    test_init<input_iterator        <const int*>, forward_iterator      <const unsigned int*> >();
+    test_init<input_iterator        <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init<input_iterator        <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init<forward_iterator      <const int*>, input_iterator        <const unsigned int*> >();
+    test_init<forward_iterator      <const int*>, forward_iterator      <const unsigned int*> >();
+    test_init<forward_iterator      <const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init<forward_iterator      <const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init<bidirectional_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test_init<bidirectional_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test_init<bidirectional_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init<bidirectional_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+    test_init<random_access_iterator<const int*>, input_iterator        <const unsigned int*> >();
+    test_init<random_access_iterator<const int*>, forward_iterator      <const unsigned int*> >();
+    test_init<random_access_iterator<const int*>, bidirectional_iterator<const unsigned int*> >();
+    test_init<random_access_iterator<const int*>, random_access_iterator<const unsigned int*> >();
+
+//  just plain pointers (const vs. non-const, too)
+    test_init<const int*, const unsigned int *>();
+    test_init<const int*,       unsigned int *>();
+    test_init<      int*, const unsigned int *>();
+    test_init<      int*,       unsigned int *>();
+}
+
+BOOST_AUTO_TEST_CASE( test_main )
+{
+  test_transform_reduce_init();
+  test_transform_reduce_init_bop_uop();
+  test_transform_reduce_init_bop_bop();
+}