From 2d62dc5f16431560410969b2e5d07f228db2339f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Jaakko=20J=C3=A4rvi?= Date: Fri, 7 Sep 2001 11:04:50 +0000 Subject: [PATCH] moved some tests that require user interaction from tuple_test_bench.cpp to another_tuple_test_bench.cpp [SVN r11059] --- test/another_tuple_test_bench.cpp | 261 +++++++++++++++--------------- test/tuple_test_bench.cpp | 129 ++++++--------- 2 files changed, 180 insertions(+), 210 deletions(-) diff --git a/test/another_tuple_test_bench.cpp b/test/another_tuple_test_bench.cpp index 73e458a..17341c1 100644 --- a/test/another_tuple_test_bench.cpp +++ b/test/another_tuple_test_bench.cpp @@ -1,161 +1,158 @@ -// another_tuple_test_bench.cpp -------------------------------- -// +// another_test_bench.cpp -------------------------------- + +// This file has various tests to see that things that shouldn't +// compile, don't compile. + +// Defining any of E1 to E5 or E7 to E11 opens some illegal code that +// should cause the compliation to fail. #define BOOST_INCLUDE_MAIN // for testing, include rather than link #include // see "Header Implementation Option" #include "boost/tuple/tuple.hpp" -#include "boost/tuple/tuple_comparison.hpp" +#include +#include using namespace std; using namespace boost; +using namespace boost::tuples; -class foo -{ + +template void dummy(const T&) {} + +class A {}; class B {}; class C {}; + +// A non-copyable class +class no_copy { + no_copy(const no_copy&) {} public: - explicit foo(int v) : val(v) {} - - bool operator==(const foo& other) const - { - return val == other.val; - } - -private: - foo() {} - int val; + no_copy() {}; }; -void -construction_test() -{ - tuple t1; - BOOST_TEST(get<0>(t1) == int()); - - tuple t2(5.5f); - BOOST_TEST(get<0>(t2) == 5.5f); +no_copy y; - tuple t3(foo(12)); - BOOST_TEST(get<0>(t3) == foo(12)); +#ifdef E1 +tuple v1; // should faild +#endif - tuple t4(t2); - BOOST_TEST(get<0>(t4) == 5.5); - tuple t5; - BOOST_TEST(get<0>(t5) == int()); - BOOST_TEST(get<1>(t5) == float()); +#ifdef E2 +char cs[10]; +tuple v3; // should fail, arrays must be stored as references +#endif - tuple t6(12, 5.5f); - BOOST_TEST(get<0>(t6) == 12); - BOOST_TEST(get<1>(t6) == 5.5f); +// a class without a public default constructor +class no_def_constructor { + no_def_constructor() {} +public: + no_def_constructor(std::string) {} // can be constructed with a string +}; - tuple t7(t6); - BOOST_TEST(get<0>(t7) == 12); - BOOST_TEST(get<1>(t7) == 5.5f); +void foo1() { + +#ifdef E3 + dummy(tuple()); + // should fail + +#endif } -void -copy_test() -{ - tuple t1(4, 12.5f); - tuple t2(5, 2.2f); - t2 = t1; - BOOST_TEST(get<0>(t1) == get<0>(t2)); - BOOST_TEST(get<1>(t1) == get<1>(t2)); +void foo2() { +// testing default values +#ifdef E4 + dummy(tuple()); // should fail, not defaults for references + dummy(tuple()); // likewise +#endif - tuple t3(2, 3.3); - t3 = t1; - BOOST_TEST((double)get<0>(t1) == get<0>(t3)); - BOOST_TEST((double)get<1>(t1) == get<1>(t3)); -} - -void -mutate_test() -{ - tuple t1(5, 12.2f, true, foo(4)); - get<0>(t1) = 6; - get<1>(t1) = 2.2f; - get<2>(t1) = false; - get<3>(t1) = foo(5); - - BOOST_TEST(get<0>(t1) == 6); - BOOST_TEST(get<1>(t1) == 2.2f); - BOOST_TEST(get<2>(t1) == false); - BOOST_TEST(get<3>(t1) == foo(5)); -} - -void -make_tuple_test() -{ - tuple t1 = make_tuple(5, 2.25f); - BOOST_TEST(get<0>(t1) == 5); - BOOST_TEST(get<1>(t1) == 2.25f); - - tuple t2; - t2 = make_tuple((short int)2, 2.25); - BOOST_TEST(get<0>(t2) == 2); - BOOST_TEST(get<1>(t2) == 2.25); -} - -void -tie_test() -{ - int a; - float b; - foo c(5); - - tie(a, b, c) = make_tuple(2, 5.5f, foo(3)); - BOOST_TEST(a == 2); - BOOST_TEST(b == 5.5f); - BOOST_TEST(c == foo(3)); - - tie(a, tuples::ignore, c) = make_tuple((short int)5, false, foo(5)); - BOOST_TEST(a == 5); - BOOST_TEST(b == 5.5f); - BOOST_TEST(c == foo(5)); -} - -void -equality_test() -{ - tuple t1(5, 3.3f); - tuple t2(5, 3.3f); - BOOST_TEST(t1 == t2); - - tuple t3(5, 2.2f); - tuple t4(2, 3.3f); - BOOST_TEST(t1 != t3); - BOOST_TEST(t1 != t4); -} - -void -ordering_test() -{ - tuple t1(4, 3.3f); - tuple t2(5, 3.3f); - tuple t3(5, 4.4); - BOOST_TEST(t1 < t2); - BOOST_TEST(t1 <= t2); - BOOST_TEST(t2 > t1); - BOOST_TEST(t2 >= t1); - BOOST_TEST(t2 < t3); - BOOST_TEST(t2 <= t3); - BOOST_TEST(t3 > t2); - BOOST_TEST(t3 >= t2); + double dd = 5; +#ifdef E5 + dummy(tuple(dd+3.14)); // should fail, temporary to non-const reference +#endif } -int -test_main(int, char *[]) + +// make_tuple ------------------------------------------ + + + void foo3() { +#ifdef E7 + std::make_pair("Doesn't","Work"); // fails +#endif + // make_tuple("Does", "Work"); // this should work +} + + + +// - testing element access + +void foo4() { - construction_test(); - copy_test(); - mutate_test(); - make_tuple_test(); - tie_test(); - equality_test(); - ordering_test(); +#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) + double d = 2.7; + A a; + tuple t(1, d, a); + const tuple ct = t; + +#ifdef E8 + get<0>(ct) = 5; // can't assign to const +#endif + +#ifdef E9 + get<4>(t) = A(); // can't assign to const +#endif +#ifdef E10 + dummy(get<5>(ct)); // illegal index +#endif + +#endif +} + +// testing copy and assignment with implicit conversions between elements +// testing tie + + class AA {}; + class BB : public AA {}; + struct CC { CC() {} CC(const BB& b) {} }; + struct DD { operator CC() const { return CC(); }; }; + + void foo5() { + tuple t; + + tuple aaa; + tuple bbb(aaa); + // tuple a = t; + // a = t; + } + + +// testing tie +// testing assignment from std::pair +void foo7() { + + tuple a; +#ifdef E11 + a = std::make_pair(1, 2); // should fail, tuple is of length 3, not 2 +#endif + + dummy(a); +} + + + +// -------------------------------- +// ---------------------------- +int test_main(int, char *[]) { + + foo1(); + foo2(); + foo3(); + foo4(); + foo5(); + + foo7(); return 0; } diff --git a/test/tuple_test_bench.cpp b/test/tuple_test_bench.cpp index 2f763b9..944d45f 100644 --- a/test/tuple_test_bench.cpp +++ b/test/tuple_test_bench.cpp @@ -1,8 +1,5 @@ // tuple_test_bench.cpp -------------------------------- -// Defining any of E1 to E5 or E7 to E11 opens some illegal code that -// should cause the compliation to fail. - #define BOOST_INCLUDE_MAIN // for testing, include rather than link #include // see "Header Implementation Option" @@ -12,10 +9,6 @@ #include #include -#include -#include -#include -#include using namespace std; using namespace boost; @@ -96,54 +89,46 @@ no_copy y; tuple x = tuple(y); // ok #endif -#ifdef E1 -tuple v1; // should faild -#endif - #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) char cs[10]; tuple v2(cs); // ok #endif -#ifdef E2 -tuple v3; // should fail, arrays must be stored as references -#endif - void construction_test() { + + // Note, the get function can be called without the tuples:: qualifier, + // as it is lifted to namespace boost with a "using tuples::get" but + // MSVC 6.0 just cannot find get without the namespace qualifier + tuple t1; - BOOST_TEST(get<0>(t1) == int()); + BOOST_TEST(tuples::get<0>(t1) == int()); tuple t2(5.5f); - BOOST_TEST(get<0>(t2) > 5.4f && get<0>(t2) < 5.6f); + BOOST_TEST(tuples::get<0>(t2) > 5.4f && tuples::get<0>(t2) < 5.6f); tuple t3(foo(12)); - BOOST_TEST(get<0>(t3) == foo(12)); + BOOST_TEST(tuples::get<0>(t3) == foo(12)); tuple t4(t2); - BOOST_TEST(get<0>(t4) > 5.4 && get<0>(t4) < 5.6); + BOOST_TEST(tuples::get<0>(t4) > 5.4 && tuples::get<0>(t4) < 5.6); tuple t5; - BOOST_TEST(get<0>(t5) == int()); - BOOST_TEST(get<1>(t5) == float()); + BOOST_TEST(tuples::get<0>(t5) == int()); + BOOST_TEST(tuples::get<1>(t5) == float()); tuple t6(12, 5.5f); - BOOST_TEST(get<0>(t6) == 12); - BOOST_TEST(get<1>(t6) > 5.4f && get<1>(t6) < 5.6f); + BOOST_TEST(tuples::get<0>(t6) == 12); + BOOST_TEST(tuples::get<1>(t6) > 5.4f && tuples::get<1>(t6) < 5.6f); tuple t7(t6); - BOOST_TEST(get<0>(t7) == 12); - BOOST_TEST(get<1>(t7) > 5.4f && get<1>(t7) < 5.6f); + BOOST_TEST(tuples::get<0>(t7) == 12); + BOOST_TEST(tuples::get<1>(t7) > 5.4f && tuples::get<1>(t7) < 5.6f); tuple t8(t6); - BOOST_TEST(get<0>(t8) == 12); - BOOST_TEST(get<1>(t8) > 5.4f && get<1>(t8) < 5.6f); - -#ifdef E3 - dummy(tuple()); - // should fail -#endif + BOOST_TEST(tuples::get<0>(t8) == 12); + BOOST_TEST(tuples::get<1>(t8) > 5.4f && tuples::get<1>(t8) < 5.6f); dummy( tuple( @@ -158,11 +143,9 @@ construction_test() dummy(tuple(1)); dummy(tuple(1,3.14)); -#ifdef E4 - dummy(tuple()); // should fail, not defaults for references - dummy(tuple()); // likewise -#endif + // dummy(tuple()); // should fail, not defaults for references + // dummy(tuple()); // likewise #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) double dd = 5; @@ -171,10 +154,8 @@ construction_test() dummy(tuple(dd+3.14)); // ok, but dangerous #endif -#ifdef E5 - dummy(tuple(dd+3.14)); // should fail, - // temporary to non-const reference -#endif + // dummy(tuple(dd+3.14)); // should fail, + // // temporary to non-const reference } @@ -191,32 +172,26 @@ void element_access_test() tuple t(1, d, a); const tuple ct = t; - int i = get<0>(t); - int j = get<0>(ct); + int i = tuples::get<0>(t); + int j = tuples::get<0>(ct); BOOST_TEST(i == 1 && j == 1); - get<0>(t) = 5; + tuples::get<0>(t) = 5; BOOST_TEST(t.head == 5); -#ifdef E8 - get<0>(ct) = 5; // can't assign to const -#endif + // tuples::get<0>(ct) = 5; // can't assign to const - double e = get<1>(t); + double e = tuples::get<1>(t); BOOST_TEST(e > 2.69 && e < 2.71); - get<1>(t) = 3.14+i; - BOOST_TEST(get<1>(t) > 4.13 && get<1>(t) < 4.15); + tuples::get<1>(t) = 3.14+i; + BOOST_TEST(tuples::get<1>(t) > 4.13 && tuples::get<1>(t) < 4.15); -#ifdef E9 - get<4>(t) = A(); // can't assign to const -#endif -#ifdef E10 - dummy(get<5>(ct)); // illegal index -#endif + // tuples::get<4>(t) = A(); // can't assign to const + // dummy(tuples::get<5>(ct)); // illegal index - ++get<0>(t); - BOOST_TEST(get<0>(t) == 6); + ++tuples::get<0>(t); + BOOST_TEST(tuples::get<0>(t) == 6); dummy(i); dummy(j); dummy(e); // avoid warns for unused variables #endif @@ -235,13 +210,13 @@ copy_test() tuple t1(4, 'a'); tuple t2(5, 'b'); t2 = t1; - BOOST_TEST(get<0>(t1) == get<0>(t2)); - BOOST_TEST(get<1>(t1) == get<1>(t2)); + BOOST_TEST(tuples::get<0>(t1) == tuples::get<0>(t2)); + BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t2)); tuple t3(2, "a"); t3 = t1; - BOOST_TEST((double)get<0>(t1) == get<0>(t3)); - BOOST_TEST(get<1>(t1) == get<1>(t3)[0]); + BOOST_TEST((double)tuples::get<0>(t1) == tuples::get<0>(t3)); + BOOST_TEST(tuples::get<1>(t1) == tuples::get<1>(t3)[0]); // testing copy and assignment with implicit conversions between elements // testing tie @@ -262,15 +237,15 @@ void mutate_test() { tuple t1(5, 12.2f, true, foo(4)); - get<0>(t1) = 6; - get<1>(t1) = 2.2f; - get<2>(t1) = false; - get<3>(t1) = foo(5); + tuples::get<0>(t1) = 6; + tuples::get<1>(t1) = 2.2f; + tuples::get<2>(t1) = false; + tuples::get<3>(t1) = foo(5); - BOOST_TEST(get<0>(t1) == 6); - BOOST_TEST(get<1>(t1) > 2.1f && get<1>(t1) < 2.3f); - BOOST_TEST(get<2>(t1) == false); - BOOST_TEST(get<3>(t1) == foo(5)); + BOOST_TEST(tuples::get<0>(t1) == 6); + BOOST_TEST(tuples::get<1>(t1) > 2.1f && tuples::get<1>(t1) < 2.3f); + BOOST_TEST(tuples::get<2>(t1) == false); + BOOST_TEST(tuples::get<3>(t1) == foo(5)); } // ---------------------------------------------------------------------------- @@ -281,13 +256,13 @@ void make_tuple_test() { tuple t1 = make_tuple(5, 'a'); - BOOST_TEST(get<0>(t1) == 5); - BOOST_TEST(get<1>(t1) == 'a'); + BOOST_TEST(tuples::get<0>(t1) == 5); + BOOST_TEST(tuples::get<1>(t1) == 'a'); tuple t2; t2 = make_tuple((short int)2, std::string("Hi")); - BOOST_TEST(get<0>(t2) == 2); - BOOST_TEST(get<1>(t2) == "Hi"); + BOOST_TEST(tuples::get<0>(t2) == 2); + BOOST_TEST(tuples::get<1>(t2) == "Hi"); #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) @@ -307,9 +282,7 @@ make_tuple_test() #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) make_tuple("Donald", "Daisy"); // should work; #endif -#ifdef E7 - std::make_pair("Doesn't","Work"); // fails -#endif + // std::make_pair("Doesn't","Work"); // fails // You can store a reference to a function in a tuple #if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION) @@ -442,8 +415,8 @@ void cons_test() void const_tuple_test() { const tuple t1(5, 3.3f); - BOOST_TEST(get<0>(t1) == 5); - BOOST_TEST(get<1>(t1) == 3.3f); + BOOST_TEST(tuples::get<0>(t1) == 5); + BOOST_TEST(tuples::get<1>(t1) == 3.3f); }