Initial commit

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/Jamfile.v2

@@ -0,0 +1,25 @@
+# Copyright David Abrahams, Jeremy Siek, Vladimir Prus
+# 2006. 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)
+import testing ;
+
+test-suite concept_check
+  : [ link stl_concept_covering.cpp ]
+    [ run stl_concept_check.cpp ]
+    [ run concept_check_test.cpp  ]
+    [ run class_concept_check_test.cpp ]
+    [ compile-fail concept_check_fail_expected.cpp ]
+    [ compile-fail class_concept_fail_expected.cpp ]
+      
+    [ run where.cpp ]
+    [ compile-fail where_fail.cpp ]
+    [ compile-fail usage_fail.cpp ]
+      
+      # Backward compatibility tests
+    [ run old_concept_pass.cpp ]
+    [ compile-fail function_requires_fail.cpp ]
+    [ compile-fail old_concept_function_fail.cpp ]
+    [ compile-fail old_concept_class_fail.cpp ]
+  ;
+

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/class_concept_check_test.cpp

@@ -0,0 +1,34 @@
+// (C) Copyright Jeremy Siek 2000.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept_check.hpp>
+
+/*
+
+  This file verifies that the BOOST_CLASS_REQUIRE macro of the Boost
+  Concept Checking Library does not cause errors when it is not suppose
+  to.
+
+*/
+
+struct foo { bool operator()(int) { return true; } };
+struct bar { bool operator()(int, char) { return true; } };
+
+class class_requires_test
+{
+    BOOST_CONCEPT_ASSERT((boost::EqualityComparable<int>));
+    typedef int* int_ptr; typedef const int* const_int_ptr;
+    BOOST_CONCEPT_ASSERT((boost::EqualOp<int_ptr,const_int_ptr>));
+    BOOST_CONCEPT_ASSERT((boost::UnaryFunction<foo,bool,int>));
+    BOOST_CONCEPT_ASSERT((boost::BinaryFunction<bar,bool,int,char>));
+};
+
+int
+main()
+{
+    class_requires_test x;
+    boost::ignore_unused_variable_warning(x);
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/class_concept_fail_expected.cpp

@@ -0,0 +1,32 @@
+// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
+// 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)
+//
+// Change Log:
+// 20 Jan 2001 - Added warning suppression (David Abrahams)
+
+#include <boost/concept_check.hpp>
+
+/*
+
+  This file verifies that class_requires of the Boost Concept Checking
+  Library catches errors when it is supposed to.
+
+*/
+
+struct foo { };
+
+template <class T>
+class class_requires_test
+{
+    BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
+};
+
+int
+main()
+{
+    class_requires_test<int> x;
+    (void)x; // suppress unused variable warning
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/concept_check_fail_expected.cpp

@@ -0,0 +1,26 @@
+// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
+// 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)
+
+#ifdef NDEBUG
+#  undef NDEBUG
+#endif
+
+#include <boost/concept_check.hpp>
+
+/*
+
+  This file verifies that BOOST_CONCEPT_ASSERT catches errors in
+  function context.
+
+*/
+
+struct foo { };
+
+int
+main()
+{
+    BOOST_CONCEPT_ASSERT((boost::EqualityComparable<foo>));
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/concept_check_test.cpp

@@ -0,0 +1,177 @@
+// (C) Copyright Jeremy Siek 2000.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept_check.hpp>
+#include <boost/concept_archetype.hpp>
+
+/*
+
+  This file verifies that function_requires() of the Boost Concept
+  Checking Library does not cause errors when it is not suppose to
+  and verifies that the concept archetypes meet the requirements of
+  their matching concepts.
+
+*/
+
+
+int
+main()
+{
+  using namespace boost;
+
+  //===========================================================================
+  // Basic Concepts
+  {
+    typedef default_constructible_archetype<> foo;
+    function_requires< DefaultConstructible<foo> >();
+  }
+  {
+    typedef assignable_archetype<> foo;
+    function_requires< Assignable<foo> >();
+  }
+  {
+    typedef copy_constructible_archetype<> foo;
+    function_requires< CopyConstructible<foo> >();
+  }
+  {
+    typedef sgi_assignable_archetype<> foo;
+    function_requires< SGIAssignable<foo> >();
+  }
+  {
+    typedef copy_constructible_archetype<> foo;
+    typedef convertible_to_archetype<foo> convertible_to_foo;
+    function_requires< Convertible<convertible_to_foo, foo> >();
+  }
+  {
+    function_requires< Convertible<boolean_archetype, bool> >();
+  }
+  {
+    typedef equality_comparable_archetype<> foo;
+    function_requires< EqualityComparable<foo> >();
+  }
+  {
+    typedef less_than_comparable_archetype<> foo;
+    function_requires< LessThanComparable<foo> >();
+  }
+  {
+    typedef comparable_archetype<> foo;
+    function_requires< Comparable<foo> >();
+  }
+  {
+    typedef equal_op_first_archetype<> First;
+    typedef equal_op_second_archetype<> Second;
+    function_requires< EqualOp<First, Second> >();
+  }
+  {
+    typedef not_equal_op_first_archetype<> First;
+    typedef not_equal_op_second_archetype<> Second;
+    function_requires< NotEqualOp<First, Second> >();
+  }
+  {
+    typedef less_than_op_first_archetype<> First;
+    typedef less_than_op_second_archetype<> Second;
+    function_requires< LessThanOp<First, Second> >();
+  }
+  {
+    typedef less_equal_op_first_archetype<> First;
+    typedef less_equal_op_second_archetype<> Second;
+    function_requires< LessEqualOp<First, Second> >();
+  }
+  {
+    typedef greater_than_op_first_archetype<> First;
+    typedef greater_than_op_second_archetype<> Second;
+    function_requires< GreaterThanOp<First, Second> >();
+  }
+  {
+    typedef greater_equal_op_first_archetype<> First;
+    typedef greater_equal_op_second_archetype<> Second;
+    function_requires< GreaterEqualOp<First, Second> >();
+  }
+
+  {
+    typedef copy_constructible_archetype<> Return;
+    typedef plus_op_first_archetype<Return> First;
+    typedef plus_op_second_archetype<Return> Second;
+    function_requires< PlusOp<Return, First, Second> >();
+  }
+
+  //===========================================================================
+  // Function Object Concepts
+
+  {
+    typedef generator_archetype<null_archetype<> > foo;
+    function_requires< Generator<foo, null_archetype<> > >();
+  }
+#if !defined BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
+  {
+    function_requires< Generator< void_generator_archetype, void > >();
+  }
+#endif
+  {
+    typedef unary_function_archetype<int, int> F;
+    function_requires< UnaryFunction<F, int, int> >();
+  }
+  {
+    typedef binary_function_archetype<int, int, int> F;
+    function_requires< BinaryFunction<F, int, int, int> >();
+  }
+  {
+    typedef unary_predicate_archetype<int> F;
+    function_requires< UnaryPredicate<F, int> >();
+  }
+  {
+    typedef binary_predicate_archetype<int, int> F;
+    function_requires< BinaryPredicate<F, int, int> >();
+  }
+
+  //===========================================================================
+  // Iterator Concepts
+  {
+    typedef input_iterator_archetype<null_archetype<> > Iter;
+    function_requires< InputIterator<Iter> >();
+  }
+  {
+    typedef output_iterator_archetype<int> Iter;
+    function_requires< OutputIterator<Iter, int> >();
+  }
+  {
+    typedef input_output_iterator_archetype<int> Iter;
+    function_requires< InputIterator<Iter> >();
+    function_requires< OutputIterator<Iter, int> >();
+  }
+  {
+    typedef forward_iterator_archetype<null_archetype<> > Iter;
+    function_requires< ForwardIterator<Iter> >();
+  }
+  {
+    typedef mutable_forward_iterator_archetype<assignable_archetype<> > Iter;
+    function_requires< Mutable_ForwardIterator<Iter> >();
+  }
+  {
+    typedef bidirectional_iterator_archetype<null_archetype<> > Iter;
+    function_requires< BidirectionalIterator<Iter> >();
+  }
+  {
+    typedef mutable_bidirectional_iterator_archetype<assignable_archetype<> > 
+      Iter;
+    function_requires< Mutable_BidirectionalIterator<Iter> >();
+  }
+  {
+    typedef random_access_iterator_archetype<null_archetype<> > Iter;
+    function_requires< RandomAccessIterator<Iter> >();
+  }
+  {
+    typedef mutable_random_access_iterator_archetype<assignable_archetype<> > 
+      Iter;
+    function_requires< Mutable_RandomAccessIterator<Iter> >();
+  }
+
+  //===========================================================================
+  // Container Concepts
+
+  // UNDER CONSTRUCTION
+
+  return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/fake_sort.hpp

@@ -0,0 +1,27 @@
+// Copyright David Abrahams 2006. 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)
+#ifndef BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
+# define BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP
+
+# include <iterator>
+# include <boost/concept/requires.hpp>
+# include <boost/concept_check.hpp>
+
+namespace fake
+{
+  using namespace boost;
+  
+  template<typename RanIter>
+  BOOST_CONCEPT_REQUIRES(
+      ((Mutable_RandomAccessIterator<RanIter>))
+      ((LessThanComparable<typename Mutable_RandomAccessIterator<RanIter>::value_type>))
+    
+    , (void))
+      sort(RanIter,RanIter)
+  {
+ 
+  }
+}
+
+#endif // BOOST_LIBS_CONCEPT_CHECK_FAKE_SORT_DWA2006430_HPP

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/function_requires_fail.cpp

@@ -0,0 +1,26 @@
+// (C) Copyright Jeremy Siek 2000.
+// 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)
+
+#ifdef NDEBUG
+#  undef NDEBUG
+#endif
+
+#include <boost/concept_check.hpp>
+
+/*
+
+  This file verifies that function_requires() of the Boost Concept
+  Checking Library catches errors when it is suppose to.
+
+*/
+
+struct foo { };
+
+int
+main()
+{
+    boost::function_requires< boost::EqualityComparable<foo> >();
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/old_concept_class_fail.cpp

@@ -0,0 +1,28 @@
+// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
+// 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)
+//
+// Change Log:
+// 20 Jan 2001 - Added warning suppression (David Abrahams)
+
+#include "old_concepts.hpp"
+
+// This file verifies that concepts written the old way still catch
+// errors in class context.  This is not expected to work on compilers
+// without SFINAE support.
+
+struct foo { };
+
+class class_requires_test
+{
+  BOOST_CLASS_REQUIRE(foo, old, EqualityComparableConcept);
+};
+
+int
+main()
+{
+  class_requires_test x;
+  (void)x; // suppress unused variable warning
+  return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/old_concept_function_fail.cpp

@@ -0,0 +1,23 @@
+// (C) Copyright Jeremy Siek 2000.
+// 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)
+
+#ifdef NDEBUG
+#  undef NDEBUG
+#endif
+
+#include "old_concepts.hpp"
+
+// This file verifies that concepts written the old way still catch
+// errors in function context.  This is not expected to work on
+// compilers without SFINAE support.
+
+struct foo { };
+
+int
+main()
+{
+    boost::function_requires< old::EqualityComparableConcept<foo> >();
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/old_concept_pass.cpp

@@ -0,0 +1,34 @@
+// (C) Copyright Jeremy Siek, David Abrahams 2000-2006.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept_check.hpp>
+#include "old_concepts.hpp"
+
+// This test verifies that use of the old-style concept checking
+// classes still compiles (but not that it detects constraint
+// violations).  We check them with the old-style macros just for
+// completeness, since those macros stranslate into
+// BOOST_CONCEPT_ASSERTs.
+
+struct foo { bool operator()(int) { return true; } };
+struct bar { bool operator()(int, char) { return true; } };
+
+
+class class_requires_test
+{
+  BOOST_CLASS_REQUIRE(int, old, EqualityComparableConcept);
+  typedef int* int_ptr; typedef const int* const_int_ptr;
+  BOOST_CLASS_REQUIRE2(int_ptr, const_int_ptr, old, EqualOpConcept);
+  BOOST_CLASS_REQUIRE3(foo, bool, int, old, UnaryFunctionConcept);
+  BOOST_CLASS_REQUIRE4(bar, bool, int, char, old, BinaryFunctionConcept);
+};
+
+int
+main()
+{
+    class_requires_test x;
+    boost::ignore_unused_variable_warning(x);
+    return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/old_concepts.hpp

@@ -0,0 +1,67 @@
+// Copyright Jeremy Siek, David Abrahams 2000-2006. 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)
+#ifndef BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
+# define BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP
+
+#include <boost/concept_check.hpp>
+
+namespace old
+{
+  template <class TT>
+  void require_boolean_expr(const TT& t) {
+    bool x = t;
+    boost::ignore_unused_variable_warning(x);
+  }
+  
+  template <class TT>
+  struct EqualityComparableConcept
+  {
+    void constraints() {
+        boost::require_boolean_expr(a == b);
+        boost::require_boolean_expr(a != b);
+    }
+    TT a, b;
+  };
+
+  template <class Func, class Return, class Arg>
+  struct UnaryFunctionConcept
+  {
+    // required in case any of our template args are const-qualified:
+    UnaryFunctionConcept();
+    
+    void constraints() {
+      r = f(arg); // require operator()
+    }
+    Func f;
+    Arg arg;
+    Return r;
+  };
+
+  template <class Func, class Return, class First, class Second>
+  struct BinaryFunctionConcept
+  {
+    void constraints() { 
+      r = f(first, second); // require operator()
+    }
+    Func f;
+    First first;
+    Second second;
+    Return r;
+  };
+
+#define DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(OP,NAME) \
+  template <class First, class Second> \
+  struct NAME { \
+    void constraints() { (void)constraints_(); } \
+    bool constraints_() {  \
+      return  a OP b; \
+    } \
+    First a; \
+    Second b; \
+  }
+
+  DEFINE_BINARY_PREDICATE_OP_CONSTRAINT(==, EqualOpConcept);
+}
+
+#endif // BOOST_LIBS_CONCEPT_CHECK_OLD_CONCEPTS_DWA2006428_HPP

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/stl_concept_check.cpp

@@ -0,0 +1,93 @@
+// (C) Copyright Jeremy Siek 2000.
+// 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)
+
+//
+// This file checks to see if various standard container
+// implementations live up to requirements specified in the C++
+// standard. As many implementations do not live to the requirements,
+// it is not uncommon for this file to fail to compile. The
+// BOOST_HIDE_EXPECTED_ERRORS macro is provided here if you want to
+// see as much of this file compile as possible.
+//
+
+#include <boost/concept_check.hpp>
+
+#include <iterator>
+#include <set>
+#include <map>
+#include <vector>
+#include <list>
+#include <deque>
+#if 0
+#include <slist>
+#endif
+
+// Define this macro if you want to hide the expected error, that is,
+// error in the various C++ standard library implementations.
+//
+//#define BOOST_HIDE_EXPECTED_ERRORS
+
+int
+main()
+{
+  using namespace boost;
+
+#if defined(_ITERATOR_) && defined(BOOST_HIDE_EXPECTED_ERRORS)
+  // VC++ STL implementation is not standard conformant and
+  // fails to pass these concept checks
+#else
+  typedef std::vector<int> Vector;
+  typedef std::deque<int> Deque;
+  typedef std::list<int> List;
+
+  // VC++ missing pointer and const_pointer typedefs
+  function_requires< Mutable_RandomAccessContainer<Vector> >();
+  function_requires< BackInsertionSequence<Vector> >();
+
+#if !(defined(__GNUC__) && defined(BOOST_HIDE_EXPECTED_ERRORS))
+#if !((defined(__sgi) || (defined(__DECCXX) && defined(_RWSTD_VER) && _RWSTD_VER <= 0x0203)) \
+  && defined(BOOST_HIDE_EXPECTED_ERRORS))
+  // old deque iterator missing n + iter operation
+  function_requires< Mutable_RandomAccessContainer<Deque> >();
+#endif
+  // warnings about signed and unsigned in old deque version
+  function_requires< FrontInsertionSequence<Deque> >();
+  function_requires< BackInsertionSequence<Deque> >();
+#endif
+
+  // VC++ missing pointer and const_pointer typedefs
+  function_requires< Mutable_ReversibleContainer<List> >();
+  function_requires< FrontInsertionSequence<List> >();
+  function_requires< BackInsertionSequence<List> >();
+
+#if 0
+  typedef BOOST_STD_EXTENSION_NAMESPACE::slist<int> SList;
+  function_requires< FrontInsertionSequence<SList> >();
+#endif
+
+  typedef std::set<int> Set;
+  typedef std::multiset<int> MultiSet;
+  typedef std::map<int,int> Map;
+  typedef std::multimap<int,int> MultiMap;
+
+  function_requires< SortedAssociativeContainer<Set> >();
+  function_requires< SimpleAssociativeContainer<Set> >();
+  function_requires< UniqueAssociativeContainer<Set> >();
+
+  function_requires< SortedAssociativeContainer<MultiSet> >();
+  function_requires< SimpleAssociativeContainer<MultiSet> >();
+  function_requires< MultipleAssociativeContainer<MultiSet> >();
+
+  function_requires< SortedAssociativeContainer<Map> >();
+  function_requires< UniqueAssociativeContainer<Map> >();
+  function_requires< PairAssociativeContainer<Map> >();
+
+  function_requires< SortedAssociativeContainer<MultiMap> >();
+  function_requires< MultipleAssociativeContainer<MultiMap> >();
+  function_requires< PairAssociativeContainer<MultiMap> >();
+#endif
+
+  return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/stl_concept_covering.cpp

@@ -0,0 +1,950 @@
+// (C) Copyright Jeremy Siek 2000-2002.
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#include <algorithm>
+#include <numeric>
+#include <boost/config.hpp>
+#include <boost/concept_check.hpp>
+#include <boost/concept_archetype.hpp>
+
+/*
+
+ This file uses the archetype classes to find out which concepts
+ actually *cover* the STL algorithms true requirements. The
+ archetypes/concepts chosen do not necessarily match the C++ standard
+ or the SGI STL documentation, but instead were chosen based on the
+ minimal concepts that current STL implementations require, which in
+ many cases is less stringent than the standard. In some places there
+ was significant differences in the implementations' requirements and
+ in those places macros were used to select different requirements,
+ the purpose being to document what the requirements of various
+ implementations are.  It is an open issue as to whether the C++
+ standard should be changed to reflect these weaker requirements.
+
+*/
+
+/**
+ * Input iterator - explanation from Peter Dimov:
+ *
+ * Requirements say that *it is convertible to the value_type, and it is, in
+ * our case. The problem however is that op== is a template and the first
+ * argument fails deduction. std::find is specified in terms of the exact
+ * expression `*it == value`, so if it doesn't compile (and it doesn't),
+ * `find(it, it, value)` won't compile either.
+ *
+ * To address this, the no_proxy variant of the input iterator is used
+ * instead.
+ */
+
+#define BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE input_iterator_archetype_no_proxy
+
+boost::detail::dummy_constructor dummy_cons;
+
+// This is a special concept needed for std::swap_ranges.
+// It is mutually convertible, and also SGIAssignable
+template <class T>
+class mutually_convertible_archetype
+{
+private:
+  mutually_convertible_archetype() { }
+public:
+  mutually_convertible_archetype(const mutually_convertible_archetype&) { }
+  mutually_convertible_archetype& 
+  operator=(const mutually_convertible_archetype&)
+    { return *this; }
+  mutually_convertible_archetype(boost::detail::dummy_constructor) { }
+
+  template <class U>
+  mutually_convertible_archetype& 
+  operator=(const mutually_convertible_archetype<U>&)
+    { return *this; }
+
+};
+
+
+// for std::accumulate
+namespace accum
+{
+  typedef boost::sgi_assignable_archetype<> Ret;
+  struct T {
+    T(const Ret&) { }
+    T(boost::detail::dummy_constructor x) { }
+  };
+  typedef boost::null_archetype<> Tin;
+  Ret operator+(const T&, const Tin&) {
+    return Ret(dummy_cons);
+  }
+}
+
+// for std::shuffle
+namespace shuffle
+{
+  struct URBG {
+    typedef unsigned int result_type;
+    result_type BOOST_CONSTEXPR static min() { return 0; }
+    result_type BOOST_CONSTEXPR static max() { return 1; }
+    result_type operator()() { return 1; }
+  };
+}
+
+// for std::inner_product
+namespace inner_prod
+{
+  typedef boost::sgi_assignable_archetype<> RetAdd;
+  typedef boost::sgi_assignable_archetype<> RetMult;
+  struct T {
+    T(const RetAdd&) { }
+    T(boost::detail::dummy_constructor x) { }
+  };
+  typedef boost::null_archetype<int> Tin1;
+  typedef boost::null_archetype<char> Tin2;
+}
+
+namespace boost { // so Koenig lookup will find
+
+  inner_prod::RetMult
+  operator*(const inner_prod::Tin1&, const inner_prod::Tin2&) {
+    return inner_prod::RetMult(dummy_cons);
+  }
+  inner_prod::RetAdd 
+  operator+(const inner_prod::T&, 
+            const inner_prod::RetMult&) {
+    return inner_prod::RetAdd(dummy_cons);
+  }
+}
+
+
+// for std::partial_sum and adj_diff
+namespace part_sum
+{
+  class T {
+  public:
+    typedef boost::sgi_assignable_archetype<> Ret;
+    T(const Ret&) { }
+    T(boost::detail::dummy_constructor x) { }  
+  private:
+    T() { }
+  };
+  T::Ret operator+(const T&, const T&) {
+    return T::Ret(dummy_cons);
+  }
+  T::Ret operator-(const T&, const T&) {
+    return T::Ret(dummy_cons);
+  }
+}
+
+// for std::power
+
+namespace power_stuff {
+  struct monoid_archetype {
+    monoid_archetype(boost::detail::dummy_constructor x) { }  
+  };
+  
+  boost::multipliable_archetype<monoid_archetype>
+  identity_element
+  (std::multiplies< boost::multipliable_archetype<monoid_archetype> >) 
+  {
+    return boost::multipliable_archetype<monoid_archetype>(dummy_cons);
+  }
+}
+
+struct tag1 { };
+struct tag2 { };
+
+
+int
+main()
+{
+  using namespace boost;
+
+  //===========================================================================
+  // Non-mutating Algorithms
+  {
+    input_iterator_archetype< null_archetype<> > in;
+    unary_function_archetype< null_archetype<> , null_archetype<> > 
+      f(dummy_cons);
+    std::for_each(in, in, f);
+  }
+  // gcc bug
+  {
+    typedef equality_comparable2_first_archetype<> Left;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE< Left > in;
+    equality_comparable2_second_archetype<> value(dummy_cons);
+    in = std::find(in, in, value);
+  }
+  {
+    typedef null_archetype<> T;
+    input_iterator_archetype<T> in;
+    unary_predicate_archetype<T> pred(dummy_cons);
+    in = std::find_if(in, in, pred);
+  }
+  {
+    forward_iterator_archetype< equality_comparable_archetype<> > fo;
+    fo = std::adjacent_find(fo, fo);
+  }
+  {
+    forward_iterator_archetype< 
+      convertible_to_archetype< null_archetype<>  > > fo;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    fo = std::adjacent_find(fo, fo, pred);
+  }
+  // gcc bug
+  {
+    typedef equal_op_first_archetype<> Left;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Left> in;
+    typedef equal_op_second_archetype<> Right;
+    forward_iterator_archetype<Right> fo;
+    in = std::find_first_of(in, in, fo, fo);
+  }
+  {
+    typedef equal_op_first_archetype<> Left;
+    typedef BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Left> InIter;
+    InIter in;
+    function_requires< InputIterator<InIter> >();
+    equal_op_second_archetype<> value(dummy_cons);
+    std::iterator_traits<InIter>::difference_type
+      n = std::count(in, in, value);
+    ignore_unused_variable_warning(n);
+  }
+  {
+    typedef input_iterator_archetype< null_archetype<> > InIter;
+    InIter in;
+    unary_predicate_archetype<null_archetype<> > pred(dummy_cons);
+    std::iterator_traits<InIter>::difference_type
+      n = std::count_if(in, in, pred);
+    ignore_unused_variable_warning(n);
+  }
+  // gcc bug
+  {
+    typedef equal_op_first_archetype<> Left;
+    typedef BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Left> InIter1;
+    InIter1 in1;
+    typedef equal_op_second_archetype<> Right;
+    typedef BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Right> InIter2;
+    InIter2 in2;
+    std::pair<InIter1, InIter2> p = std::mismatch(in1, in1, in2);
+    ignore_unused_variable_warning(p);
+  }
+  {
+    typedef input_iterator_archetype<null_archetype<> > InIter;
+    InIter in1, in2;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    std::pair<InIter, InIter> p = std::mismatch(in1, in1, in2, pred);
+    ignore_unused_variable_warning(p);
+  }
+  // gcc bug
+  {
+    typedef equality_comparable2_first_archetype<> Left;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Left> in1;
+    typedef equality_comparable2_second_archetype<> Right;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Right> in2;
+    bool b = std::equal(in1, in1, in2);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    input_iterator_archetype< null_archetype<> >
+      in1, in2;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    bool b = std::equal(in1, in1, in2, pred);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef equality_comparable2_first_archetype<> Left;
+    forward_iterator_archetype<Left> fo1;
+    typedef equality_comparable2_second_archetype<> Right;
+    forward_iterator_archetype<Right> fo2;
+    fo1 = std::search(fo1, fo1, fo2, fo2);
+  }
+  {
+    typedef equality_comparable2_first_archetype< 
+      convertible_to_archetype<null_archetype<> > > Left;
+    forward_iterator_archetype<Left> fo1;
+    typedef equality_comparable2_second_archetype<
+      convertible_to_archetype<null_archetype<> > > Right;
+    forward_iterator_archetype<Right> fo2;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    fo1 = std::search(fo1, fo1, fo2, fo2, pred);
+  }
+  {
+    typedef equality_comparable2_first_archetype<> Left;
+    forward_iterator_archetype<Left> fo;
+    equality_comparable2_second_archetype<> value(dummy_cons);
+    int n = 1;
+    fo = std::search_n(fo, fo, n, value);
+  }
+  {
+    forward_iterator_archetype< 
+      convertible_to_archetype<null_archetype<> > > fo;
+    convertible_to_archetype<null_archetype<> > value(dummy_cons);
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    int n = 1;
+    fo = std::search_n(fo, fo, n, value, pred);
+  }
+  {
+    typedef equality_comparable2_first_archetype<> Left;
+    forward_iterator_archetype<Left> fo1;
+    typedef equality_comparable2_second_archetype<null_archetype<> > Right;
+    forward_iterator_archetype<Right> fo2;
+    fo1 = std::find_end(fo1, fo1, fo2, fo2);
+  }
+  {
+    // equality comparable required because find_end() calls search
+    typedef equality_comparable2_first_archetype<
+      convertible_to_archetype<null_archetype<> > > Left;
+    forward_iterator_archetype<Left> fo1;
+    typedef equality_comparable2_second_archetype<
+      convertible_to_archetype<null_archetype<> > > Right;
+    forward_iterator_archetype<Right> fo2;
+    binary_predicate_archetype<null_archetype<> , null_archetype<> > 
+      pred(dummy_cons);
+    fo1 = std::find_end(fo1, fo1, fo2, fo2, pred);
+  }
+
+  //===========================================================================
+  // Mutating Algorithms
+
+  {
+    typedef null_archetype<> T;
+    input_iterator_archetype<T> in;
+    output_iterator_archetype<T> out(dummy_cons);
+    out = std::copy(in, in, out);
+  }
+  {
+    typedef assignable_archetype<> OutT;
+    typedef convertible_to_archetype<OutT> InT;
+    bidirectional_iterator_archetype<InT> bid_in;
+    mutable_bidirectional_iterator_archetype<OutT> bid_out;
+    bid_out = std::copy_backward(bid_in, bid_in, bid_out);
+  }
+  {
+    sgi_assignable_archetype<> a(dummy_cons), b(dummy_cons);
+    std::swap(a, b);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_forward_iterator_archetype<T> a, b;
+    std::iter_swap(a, b);
+  }
+#if 0
+  {
+    // fails on gcc 7.3 and clang 6.0
+    typedef mutually_convertible_archetype<int> Tin;
+    typedef mutually_convertible_archetype<char> Tout;
+    mutable_forward_iterator_archetype<Tin> fi1;
+    mutable_forward_iterator_archetype<Tout> fi2;
+    fi2 = std::swap_ranges(fi1, fi1, fi2);
+  }
+#endif
+  {
+    typedef null_archetype<int> Tin;
+    typedef null_archetype<char> Tout;
+    input_iterator_archetype<Tin> in;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    unary_function_archetype<null_archetype<> , 
+      convertible_to_archetype<Tout> > op(dummy_cons);
+    out = std::transform(in, in, out, op);
+  }
+  {
+    typedef null_archetype<int> Tin1;
+    typedef null_archetype<char> Tin2;
+    typedef null_archetype<double> Tout;
+    input_iterator_archetype<Tin1> in1;
+    input_iterator_archetype<Tin2> in2;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    binary_function_archetype<Tin1, Tin2,
+      convertible_to_archetype<Tout> > op(dummy_cons);
+    out = std::transform(in1, in1, in2, out, op);
+  }
+  {
+    typedef equality_comparable2_first_archetype<
+      assignable_archetype<> > FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    equality_comparable2_second_archetype<
+      convertible_to_archetype<FT> > value(dummy_cons);
+    std::replace(fi, fi, value, value);
+  }
+  {
+    typedef null_archetype<> PredArg;
+    typedef assignable_archetype< 
+      convertible_to_archetype<PredArg> > FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    convertible_to_archetype<FT> value(dummy_cons);
+    std::replace_if(fi, fi, pred, value);
+  }
+#if (!defined(BOOST_MSVC) || BOOST_WORKAROUND(BOOST_MSVC, > 1900)) && !defined(BOOST_EMBTC)
+  // fails on MSVC 2015 and earlier
+  {
+    // Issue, the use of ?: inside replace_copy() complicates things
+    typedef equal_op_first_archetype<> Tin;
+    typedef null_archetype<> Tout;
+    typedef equal_op_second_archetype< convertible_to_archetype<Tout> > T;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin> in;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    T value(dummy_cons);
+    out = std::replace_copy(in, in, out, value, value);
+  }
+  {
+    // The issue of ?: also affects this function
+    typedef null_archetype<> Tout;
+    typedef assignable_archetype< convertible_to_archetype<Tout> > Tin;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin> in;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    unary_predicate_archetype<Tin> pred(dummy_cons);
+    Tin value(dummy_cons);
+    out = std::replace_copy_if(in, in, out, pred, value);
+  }
+#endif
+  {
+    typedef assignable_archetype<> FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    typedef convertible_to_archetype<FT> T;
+    T value(dummy_cons);
+    std::fill(fi, fi, value);
+  }  
+#if !defined(BOOST_MSVC) || BOOST_WORKAROUND(BOOST_MSVC, >= 1700)
+  // fails on MSVC 2010
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> T;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    T value(dummy_cons);
+    int n = 1;
+    out = std::fill_n(out, n, value);
+  }
+#endif
+  {
+    typedef assignable_archetype<> FT;
+    typedef convertible_to_archetype<FT> Ret;
+    mutable_forward_iterator_archetype<FT> fi;
+    generator_archetype<Ret> gen;
+    std::generate(fi, fi, gen);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    typedef convertible_to_archetype<FT> Ret;
+    mutable_forward_iterator_archetype<FT> fi;
+    generator_archetype<Ret> gen;
+    int n = 1;
+    std::generate_n(fi, n, gen);
+  }
+  {
+    typedef assignable_archetype< equality_comparable2_first_archetype<> > FT;
+    typedef equality_comparable2_second_archetype<> T;
+    mutable_forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    fi = std::remove(fi, fi, value);
+  }
+  {
+    typedef assignable_archetype<> FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    typedef null_archetype<> PredArg;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    fi = std::remove_if(fi, fi, pred);
+  }
+  // gcc bug
+  {
+    typedef null_archetype<> Tout;
+    typedef equality_comparable2_first_archetype<
+      convertible_to_archetype<Tout> > Tin;
+    typedef equality_comparable2_second_archetype<> T;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin> in;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    T value(dummy_cons);
+    out = std::remove_copy(in, in, out, value);
+  }
+  {
+    typedef null_archetype<> T;
+    input_iterator_archetype<T> in;
+    output_iterator_archetype<T> out(dummy_cons);
+    unary_predicate_archetype<T> pred(dummy_cons);
+    out = std::remove_copy_if(in, in, out, pred);
+  }
+  {
+    typedef sgi_assignable_archetype< equality_comparable_archetype<> > T;
+    mutable_forward_iterator_archetype<T> fi;
+    fi = std::unique(fi, fi);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > > FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    binary_predicate_archetype<Arg1, Arg2> pred(dummy_cons);
+    fi = std::unique(fi, fi, pred);
+  }
+  // gcc bug
+  {
+    typedef equality_comparable_archetype< sgi_assignable_archetype<> > T;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<T> in;
+    output_iterator_archetype<T> out(dummy_cons);
+    out = std::unique_copy(in, in, out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    input_iterator_archetype<T> in;
+    output_iterator_archetype<T> out(dummy_cons);
+    binary_predicate_archetype<T, T> pred(dummy_cons);
+    out = std::unique_copy(in, in, out, pred);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_bidirectional_iterator_archetype<T> bi;
+    std::reverse(bi, bi);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> Tin;
+    bidirectional_iterator_archetype<Tin> bi;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    out = std::reverse_copy(bi, bi, out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_forward_iterator_archetype<T> fi;
+    // Issue, SGI STL is not have void return type, C++ standard does
+    std::rotate(fi, fi, fi);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef convertible_to_archetype<Tout> FT;
+    forward_iterator_archetype<FT> fi;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    out = std::rotate_copy(fi, fi, fi, out);
+  }
+#ifndef BOOST_NO_CXX98_RANDOM_SHUFFLE
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_random_access_iterator_archetype<T> ri;
+    std::random_shuffle(ri, ri);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_random_access_iterator_archetype<T> ri;
+    unary_function_archetype<std::ptrdiff_t, std::ptrdiff_t> ran(dummy_cons);
+    std::random_shuffle(ri, ri, ran);
+  }
+#else
+  {
+    typedef sgi_assignable_archetype<> T;
+    mutable_random_access_iterator_archetype<T> ri;
+    shuffle::URBG urbg;
+    std::shuffle(ri, ri, urbg);
+  }
+#endif
+  {
+    typedef null_archetype<> PredArg;
+    typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
+    mutable_bidirectional_iterator_archetype<FT> bi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    bi = std::partition(bi, bi, pred);
+  }
+#if !defined(BOOST_MSVC) && !defined(BOOST_EMBTC)
+  {
+    // fails on MSVC
+    typedef null_archetype<> PredArg;
+    typedef sgi_assignable_archetype<convertible_to_archetype<PredArg> > FT;
+    mutable_forward_iterator_archetype<FT> fi;
+    unary_predicate_archetype<PredArg> pred(dummy_cons);
+    fi = std::stable_partition(fi, fi, pred);
+  }
+#endif
+  //===========================================================================
+  // Sorting Algorithms
+  {
+    typedef sgi_assignable_archetype< 
+      less_than_comparable_archetype<> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    std::sort(ri, ri);
+  }
+  {
+    typedef null_archetype<> Arg;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    std::sort(ri, ri, comp);
+  }
+  {
+    typedef less_than_comparable_archetype< 
+        sgi_assignable_archetype<> > ValueType;
+    mutable_random_access_iterator_archetype<ValueType> ri;
+    std::stable_sort(ri, ri);
+  }
+  {
+    typedef null_archetype<> Arg;
+    typedef sgi_assignable_archetype<
+      convertible_to_archetype<Arg> > ValueType;
+    mutable_random_access_iterator_archetype<ValueType> ri;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    std::stable_sort(ri, ri, comp);
+  }
+  {
+    typedef sgi_assignable_archetype< 
+      less_than_comparable_archetype<> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    std::partial_sort(ri, ri, ri);
+  }
+
+  {
+    typedef null_archetype<> Arg;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    std::partial_sort(ri, ri, ri, comp);
+  }
+  // gcc bug
+  {
+    // This could be formulated so that the two iterators are not
+    // required to have the same value type, but it is messy.
+    typedef sgi_assignable_archetype< 
+      less_than_comparable_archetype<> > T;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<T> in;
+    mutable_random_access_iterator_archetype<T> ri_out;
+    ri_out = std::partial_sort_copy(in, in , ri_out, ri_out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    input_iterator_archetype<T> in;
+    mutable_random_access_iterator_archetype<T> ri_out;
+    binary_predicate_archetype<T, T> comp(dummy_cons);
+    ri_out = std::partial_sort_copy(in, in , ri_out, ri_out, comp);
+  }
+  {
+    typedef sgi_assignable_archetype< less_than_comparable_archetype<> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    std::nth_element(ri, ri, ri);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef sgi_assignable_archetype<
+      convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
+    std::nth_element(ri, ri, ri, comp);
+  }
+  {
+#if defined(__KCC)
+    // The KAI version of this uses a one-argument less-than function
+    // object.
+    typedef less_than_comparable_archetype<> T;
+    typedef convertible_to_archetype<T> FT;
+#else
+    typedef less_than_op_first_archetype<> FT;
+    typedef less_than_op_second_archetype<> T;
+#endif
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    fi = std::lower_bound(fi, fi, value);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef convertible_to_archetype<Arg1> FT;
+    typedef convertible_to_archetype<Arg2> T;
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
+    fi = std::lower_bound(fi, fi, value, comp);
+  }
+  {
+#if defined(__KCC)
+    typedef less_than_comparable_archetype<> T;
+    typedef convertible_to_archetype<T> FT;
+#else
+    // Note, order of T,FT is flipped from lower_bound
+    typedef less_than_op_second_archetype<> FT;
+    typedef less_than_op_first_archetype<> T;
+#endif
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    fi = std::upper_bound(fi, fi, value);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    // Note, order of T,FT is flipped from lower_bound
+    typedef convertible_to_archetype<Arg1> T;
+    typedef convertible_to_archetype<Arg2> FT;
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
+    fi = std::upper_bound(fi, fi, value, comp);
+  }
+#if !defined(BOOST_MSVC) || BOOST_WORKAROUND(BOOST_MSVC, >= 1900)
+  // Fails on MSVC 2013 and earlier
+  {
+#if defined(__KCC)
+    typedef less_than_comparable_archetype<> T;
+    typedef convertible_to_archetype<T> FT;
+#else
+    typedef less_than_op_first_archetype<
+      less_than_op_second_archetype< null_archetype<>, optag2>, optag1> FT;
+    typedef less_than_op_second_archetype<
+      less_than_op_first_archetype< null_archetype<>, optag2>, optag1> T;
+#endif
+    typedef forward_iterator_archetype<FT> FIter;
+    FIter fi;
+    T value(dummy_cons);
+    std::pair<FIter,FIter> p = std::equal_range(fi, fi, value);
+    ignore_unused_variable_warning(p);
+  }
+#endif
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > FT;
+    typedef convertible_to_archetype<Arg2,
+      convertible_to_archetype<Arg1> > T;
+    typedef forward_iterator_archetype<FT> FIter;
+    FIter fi;
+    T value(dummy_cons);
+    binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
+    std::pair<FIter,FIter> p = std::equal_range(fi, fi, value, comp);
+    ignore_unused_variable_warning(p);
+  }
+  {
+#if defined(__KCC)
+    typedef less_than_op_first_archetype< less_than_comparable_archetype<> > T;
+    typedef less_than_op_second_archetype< convertible_to_archetype<T> > FT;
+#else
+    typedef less_than_op_first_archetype<
+      less_than_op_second_archetype<null_archetype<>, optag2>, optag1> FT;
+    typedef less_than_op_second_archetype<
+      less_than_op_first_archetype<null_archetype<>, optag2>, optag1> T;
+#endif
+    forward_iterator_archetype<FT> fi;
+    T value(dummy_cons);
+    bool b = std::binary_search(fi, fi, value);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef convertible_to_archetype<Arg1,
+      convertible_to_archetype<Arg2> > FT;
+    typedef convertible_to_archetype<Arg2,
+      convertible_to_archetype<Arg1> > T;
+    typedef forward_iterator_archetype<FT> FIter;
+    FIter fi;
+    T value(dummy_cons);
+    binary_predicate_archetype<Arg1, Arg2> comp(dummy_cons);
+    bool b = std::binary_search(fi, fi, value, comp);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef null_archetype<> Tout;
+    typedef less_than_op_first_archetype<
+      less_than_op_second_archetype<
+      convertible_to_archetype<Tout>, optag2>, optag1 > Tin1;
+    typedef less_than_op_second_archetype<
+      less_than_op_first_archetype<
+      convertible_to_archetype<Tout>, optag2> ,optag1> Tin2;
+    // gcc bug
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin1> in1;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin2> in2;
+    output_iterator_archetype<Tout> out(dummy_cons);
+    out = std::merge(in1, in1, in2, in2, out);
+    out = std::set_union(in1, in1, in2, in2, out);
+    out = std::set_intersection(in1, in1, in2, in2, out);
+    out = std::set_difference(in1, in1, in2, in2, out);
+    out = std::set_symmetric_difference(in1, in1, in2, in2, out);
+  }
+  {
+    typedef null_archetype<> T;
+    input_iterator_archetype<T> in1;
+    input_iterator_archetype<T,2> in2;
+    output_iterator_archetype<T> out(dummy_cons);
+    binary_predicate_archetype<T, T> comp(dummy_cons);
+    out = std::merge(in1, in1, in2, in2, out, comp);
+    out = std::set_union(in1, in1, in2, in2, out, comp);
+    out = std::set_intersection(in1, in1, in2, in2, out, comp);
+    out = std::set_difference(in1, in1, in2, in2, out, comp);
+    out = std::set_symmetric_difference(in1, in1, in2, in2, out, comp);
+  }
+  {
+    typedef sgi_assignable_archetype< 
+      less_than_comparable_archetype<> > T;
+    mutable_bidirectional_iterator_archetype<T> bi;
+    std::inplace_merge(bi, bi, bi);
+  }
+  {
+    typedef null_archetype<> Arg;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg> > T;
+    mutable_bidirectional_iterator_archetype<T> bi;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    std::inplace_merge(bi, bi, bi, comp);
+  }
+  // gcc bug
+  {
+    typedef less_than_op_first_archetype<
+      less_than_op_second_archetype<null_archetype<>, optag1>, optag2> Tin1;
+    typedef less_than_op_second_archetype<
+      less_than_op_first_archetype<null_archetype<>, optag1>, optag2> Tin2;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin1> in1;
+    BOOST_CONCEPT_CHECK_COMPATIBLE_INPUT_ITERATOR_ARCHETYPE<Tin2> in2;
+    bool b = std::includes(in1, in1, in2, in2);
+    b = std::lexicographical_compare(in1, in1, in2, in2);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef null_archetype<int> Tin;
+    input_iterator_archetype<Tin> in1;
+    input_iterator_archetype<Tin,1> in2;
+    binary_predicate_archetype<Tin, Tin> comp(dummy_cons);
+    bool b = std::includes(in1, in1, in2, in2, comp);
+    b = std::lexicographical_compare(in1, in1, in2, in2, comp);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef sgi_assignable_archetype<
+      less_than_comparable_archetype<> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    std::push_heap(ri, ri);
+    std::pop_heap(ri, ri);
+    std::make_heap(ri, ri);
+    std::sort_heap(ri, ri);
+  }
+  {
+    typedef null_archetype<> Arg;
+    typedef sgi_assignable_archetype< 
+      convertible_to_archetype<Arg> > T;
+    mutable_random_access_iterator_archetype<T> ri;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    std::push_heap(ri, ri, comp);
+    std::pop_heap(ri, ri, comp);
+    std::make_heap(ri, ri, comp);
+    std::sort_heap(ri, ri, comp);
+  }
+  {
+    typedef less_than_comparable_archetype<> T;
+    T a(dummy_cons), b(dummy_cons);
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    const T& c = min BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
+    const T& d = max BOOST_PREVENT_MACRO_SUBSTITUTION(a, b);
+    ignore_unused_variable_warning(c);
+    ignore_unused_variable_warning(d);
+  }
+  {
+    typedef null_archetype<> Arg;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    typedef convertible_to_archetype<Arg> T;
+    T a(dummy_cons), b(dummy_cons);
+    BOOST_USING_STD_MIN();
+    BOOST_USING_STD_MAX();
+    const T& c = min BOOST_PREVENT_MACRO_SUBSTITUTION(a, b, comp);
+    const T& d = max BOOST_PREVENT_MACRO_SUBSTITUTION(a, b, comp);
+    ignore_unused_variable_warning(c);
+    ignore_unused_variable_warning(d);
+  }
+  {
+    typedef less_than_comparable_archetype<> T;
+    forward_iterator_archetype<T> fi;
+    fi = std::min_element(fi, fi);
+    fi = std::max_element(fi, fi);
+  }
+  {
+    typedef null_archetype<> Arg;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    typedef convertible_to_archetype<Arg> T;
+    forward_iterator_archetype<T> fi;
+    fi = std::min_element(fi, fi, comp);
+    fi = std::max_element(fi, fi, comp);
+  }
+  {
+    typedef sgi_assignable_archetype<
+      less_than_comparable_archetype<> > T;
+    mutable_bidirectional_iterator_archetype<T> bi;
+    bool b = std::next_permutation(bi, bi);
+    b = std::prev_permutation(bi, bi);
+    ignore_unused_variable_warning(b);
+  }
+  {
+    typedef null_archetype<> Arg;
+    binary_predicate_archetype<Arg, Arg> comp(dummy_cons);
+    typedef sgi_assignable_archetype<
+      convertible_to_archetype<Arg> > T;
+    mutable_bidirectional_iterator_archetype<T> bi;
+    bool b = std::next_permutation(bi, bi, comp);
+    b = std::prev_permutation(bi, bi, comp);
+    ignore_unused_variable_warning(b);
+  }
+  //===========================================================================
+  // Generalized Numeric Algorithms
+
+  {
+    // Bummer, couldn't use plus_op because of a problem with
+    // mutually recursive types.
+    input_iterator_archetype<accum::Tin> in;
+    accum::T init(dummy_cons);
+    init = std::accumulate(in, in, init);
+  }
+  {
+    typedef null_archetype<int> Arg1;
+    typedef null_archetype<char> Arg2;
+    typedef sgi_assignable_archetype<
+      convertible_to_archetype<Arg1> > T;
+    typedef convertible_to_archetype<T> Ret;
+    input_iterator_archetype<Arg2> in;
+    T init(dummy_cons);
+    binary_function_archetype<Arg1, Arg2, Ret> op(dummy_cons);
+    init = std::accumulate(in, in, init, op);
+  }
+  {
+    input_iterator_archetype<inner_prod::Tin1> in1;
+    input_iterator_archetype<inner_prod::Tin2> in2;
+    inner_prod::T init(dummy_cons);
+    init = std::inner_product(in1, in1, in2, init);
+  }
+  {
+    typedef null_archetype<int> MultArg1;
+    typedef null_archetype<char> MultArg2;
+    typedef null_archetype<short> AddArg1;
+    typedef null_archetype<long> AddArg2;
+    typedef sgi_assignable_archetype<
+      convertible_to_archetype<AddArg1> > T;
+    typedef convertible_to_archetype<AddArg2> RetMult;
+    typedef convertible_to_archetype<T> RetAdd;
+    input_iterator_archetype<MultArg1> in1;
+    input_iterator_archetype<MultArg2> in2;
+    T init(dummy_cons);
+    binary_function_archetype<MultArg1, MultArg2, RetMult> mult_op(dummy_cons);
+    binary_function_archetype<AddArg1, AddArg2, RetAdd> add_op(dummy_cons);
+    init = std::inner_product(in1, in1, in2, init, add_op, mult_op);
+  }
+  {
+    input_iterator_archetype<part_sum::T> in;
+    output_iterator_archetype<part_sum::T> out(dummy_cons);
+    out = std::partial_sum(in, in, out);
+  }
+  {
+    typedef sgi_assignable_archetype<> T;
+    input_iterator_archetype<T> in;
+    output_iterator_archetype<T> out(dummy_cons);
+    binary_function_archetype<T, T, T> add_op(dummy_cons);
+    out = std::partial_sum(in, in, out, add_op);
+    binary_function_archetype<T, T, T> subtract_op(dummy_cons);
+    out = std::adjacent_difference(in, in, out, subtract_op);
+  }
+  {
+    input_iterator_archetype<part_sum::T> in;
+    output_iterator_archetype<part_sum::T> out(dummy_cons);
+    out = std::adjacent_difference(in, in, out);
+  }
+  return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/usage_fail.cpp

@@ -0,0 +1,24 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+#include <boost/concept/usage.hpp>
+#include <boost/core/ignore_unused.hpp>
+
+template <class T>
+struct StringInitializable
+{
+    typedef int associated;
+    BOOST_CONCEPT_USAGE(StringInitializable)
+    {
+        T x = "foo";
+        boost::ignore_unused(x);
+    }
+};
+
+// Test that accessing an associated type will actually exercise usage
+// requirements
+typedef StringInitializable<int>::associated tee;
+
+
+

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/where.cpp

@@ -0,0 +1,13 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#include <vector>
+#undef NDEBUG
+#include "fake_sort.hpp"
+
+int main()
+{
+  std::vector<int> v;
+  fake::sort(v.begin(), v.end());
+  return 0;
+}

externals/vcpkg/buildtrees/boost-concept-check/src/ost-1.79.0-c4bb71ebed.clean/test/where_fail.cpp

@@ -0,0 +1,13 @@
+// Copyright David Abrahams 2006. Distributed under the Boost
+// Software License, Version 1.0. (See accompanying
+// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+#include <list>
+#undef NDEBUG
+#include "fake_sort.hpp"
+
+int main()
+{
+  std::list<int> v;
+  fake::sort(v.begin(), v.end());
+  return 0;
+}