ceph/src/boost/libs/tuple/test/another_tuple_test_bench.cpp

   1 // Copyright (C) 1999, 2000 Jaakko Jarvi (jaakko.jarvi@cs.utu.fi)
   2 //
   3 // Distributed under the Boost Software License, Version 1.0. (See
   4 // accompanying file LICENSE_1_0.txt or copy at
   5 // http://www.boost.org/LICENSE_1_0.txt)
   6
   7 // For more information, see http://www.boost.org
   8
   9
  10 //  another_test_bench.cpp  --------------------------------
  11
  12 // This file has various tests to see that things that shouldn't
  13 // compile, don't compile.
  14
  15 // Defining any of E1 to E5 or E7 to E11 opens some illegal code that
  16 // should cause the compliation to fail.
  17
  18 #include "boost/tuple/tuple.hpp"
  19
  20 #include "boost/core/lightweight_test.hpp"
  21
  22 #include <string>
  23 #include <utility>
  24
  25 using namespace boost;
  26 using namespace boost::tuples;
  27
  28
  29 template<class T> void dummy(const T&) {}
  30
  31 class A {}; class B {}; class C {};
  32
  33 // A non-copyable class
  34 class no_copy {
  35   no_copy(const no_copy&) {}
  36 public:
  37   no_copy() {};
  38 };
  39
  40 no_copy y;
  41
  42 #ifdef E1
  43 tuple<no_copy> v1;  // should faild
  44 #endif
  45
  46
  47 #ifdef E2
  48 char cs[10];
  49 tuple<char[10]> v3;  // should fail, arrays must be stored as references
  50 #endif
  51
  52 // a class without a public default constructor
  53 class no_def_constructor {
  54   no_def_constructor() {}
  55 public:
  56   no_def_constructor(std::string) {} // can be constructed with a string
  57 };
  58
  59 void foo1() {
  60
  61 #ifdef E3
  62   dummy(tuple<no_def_constructor, no_def_constructor, no_def_constructor>());
  63   // should fail
  64
  65 #endif
  66 }
  67
  68 void foo2() {
  69 // testing default values
  70 #ifdef E4
  71   dummy(tuple<double&>()); // should fail, not defaults for references
  72   dummy(tuple<const double&>()); // likewise
  73 #endif
  74
  75 #ifdef E5
  76   double dd = 5;
  77   dummy(tuple<double&>(dd+3.14)); // should fail, temporary to non-const reference
  78 #endif
  79 }
  80
  81
  82
  83 // make_tuple ------------------------------------------
  84
  85
  86    void foo3() {
  87 #ifdef E7
  88     std::make_pair("Doesn't","Work"); // fails
  89 #endif
  90     //    make_tuple("Does", "Work"); // this should work
  91 }
  92
  93
  94
  95 // - testing element access
  96
  97 void foo4()
  98 {
  99   double d = 2.7;
 100   A a;
 101   tuple<int, double&, const A&> t(1, d, a);
 102   const tuple<int, double&, const A> ct = t;
 103   (void)ct;
 104 #ifdef E8
 105   get<0>(ct) = 5; // can't assign to const
 106 #endif
 107
 108 #ifdef E9
 109   get<4>(t) = A(); // can't assign to const
 110 #endif
 111 #ifdef E10
 112   dummy(get<5>(ct)); // illegal index
 113 #endif
 114 }
 115
 116 // testing copy and assignment with implicit conversions between elements
 117 // testing tie
 118
 119   class AA {};
 120   class BB : public AA {};
 121   struct CC { CC() {} CC(const BB& b) {} };
 122   struct DD { operator CC() const { return CC(); }; };
 123
 124   void foo5() {
 125     tuple<char, BB*, BB, DD> t;
 126     (void)t;
 127     tuple<char, char> aaa;
 128     tuple<int, int> bbb(aaa);
 129     (void)bbb;
 130     //    tuple<int, AA*, CC, CC> a = t;
 131     //    a = t;
 132   }
 133
 134
 135 // testing tie
 136 // testing assignment from std::pair
 137 void foo7() {
 138
 139    tuple<int, int, float> a;
 140 #ifdef E11
 141    a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2
 142 #endif
 143
 144     dummy(a);
 145 }
 146
 147
 148
 149 // --------------------------------
 150 // ----------------------------
 151 int main() {
 152
 153   foo1();
 154   foo2();
 155   foo3();
 156   foo4();
 157   foo5();
 158
 159   foo7();
 160
 161   return boost::report_errors();
 162 }