generic-library/boost
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

[DEV] add v1.76.0

Browse Source
This commit is contained in:
Edouard DUPIN
2021-10-05 21:37:46 +02:00
parent a97e9ae7d4
commit d0115b733d
45133 changed files with 4744437 additions and 1026325 deletions
Download Patch File Download Diff File Expand all files Collapse all files

136
libs/contract/test/public_function/access.cpp Normal file
View File

@@ -0,0 +1,136 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test making all contract extra declarations (base types, inv, etc.) private.
#include "../detail/oteststream.hpp"
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/assert.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
class b {
friend class boost::contract::access;
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
public:
virtual void f(char ch, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([&] {
out << "b::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'b');
})
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
;
out << "b::f::body" << std::endl;
}
};
class a
#define BASES public b
: BASES
{
friend class boost::contract::access;
// Private base types.
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
// Private invariants.
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
// Private override (always possible even when access is not friend).
BOOST_CONTRACT_OVERRIDE(f)
public:
virtual void f(char ch, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this, ch)
.precondition([&] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'a');
})
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f('a');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
b bb;
out.str("");
bb.f('b');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
#endif
<< "b::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

162
libs/contract/test/public_function/decl.hpp Normal file
View File

@@ -0,0 +1,162 @@
#ifndef BOOST_CONTRACT_TEST_PUBLIC_FUNCTION_DECL_HPP_
#define BOOST_CONTRACT_TEST_PUBLIC_FUNCTION_DECL_HPP_
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with and without pre, post, and inv declarations.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/assert.hpp>
boost::contract::test::detail::oteststream out;
bool c_pre = true, c_post = true;
bool c_entering_static_inv = true, c_entry_static_inv = true,
c_exit_static_inv = true;
bool c_entering_inv = true, c_entry_inv = true, c_exit_inv = true;
struct c {
#ifndef BOOST_CONTRACT_TEST_NO_C_STATIC_INV
static void static_invariant() {
out << "c::static_inv" << std::endl;
if(c_entering_static_inv) BOOST_CONTRACT_ASSERT(c_entry_static_inv);
else BOOST_CONTRACT_ASSERT(c_exit_static_inv);
c_entering_static_inv = false;
}
#endif
#ifndef BOOST_CONTRACT_TEST_NO_C_INV
void invariant() const {
out << "c::inv" << std::endl;
if(c_entering_inv) BOOST_CONTRACT_ASSERT(c_entry_inv);
else BOOST_CONTRACT_ASSERT(c_exit_inv);
c_entering_inv = false;
}
#endif
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
#ifndef BOOST_CONTRACT_TEST_NO_C_PRE
.precondition([] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(c_pre);
})
#endif
.old([] { out << "c::f::old" << std::endl; })
#ifndef BOOST_CONTRACT_TEST_NO_C_POST
.postcondition([] {
out << "c::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(c_post);
})
#endif
;
out << "c::f::body" << std::endl;
}
};
bool b_pre = true, b_post = true;
bool b_entering_static_inv = true, b_entry_static_inv = true,
b_exit_static_inv = true;
bool b_entering_inv = true, b_entry_inv = true, b_exit_inv = true;
struct b
#define BASES public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
#ifndef BOOST_CONTRACT_TEST_NO_B_STATIC_INV
static void static_invariant() {
out << "b::static_inv" << std::endl;
if(b_entering_static_inv) BOOST_CONTRACT_ASSERT(b_entry_static_inv);
else BOOST_CONTRACT_ASSERT(b_exit_static_inv);
b_entering_static_inv = false;
}
#endif
#ifndef BOOST_CONTRACT_TEST_NO_B_INV
void invariant() const {
out << "b::inv" << std::endl;
if(b_entering_inv) BOOST_CONTRACT_ASSERT(b_entry_inv);
else BOOST_CONTRACT_ASSERT(b_exit_inv);
b_entering_inv = false;
}
#endif
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
#ifndef BOOST_CONTRACT_TEST_NO_B_PRE
.precondition([] {
out << "b::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(b_pre);
})
#endif
.old([] { out << "b::f::old" << std::endl; })
#ifndef BOOST_CONTRACT_TEST_NO_B_POST
.postcondition([] {
out << "b::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(b_post);
})
#endif
;
out << "a::f::body" << std::endl;
}
};
bool a_pre = true, a_post = true;
bool a_entering_static_inv = true, a_entry_static_inv = true,
a_exit_static_inv = true;
bool a_entering_inv = true, a_entry_inv = true, a_exit_inv = true;
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
#ifndef BOOST_CONTRACT_TEST_NO_A_STATIC_INV
static void static_invariant() {
out << "a::static_inv" << std::endl;
if(a_entering_static_inv) BOOST_CONTRACT_ASSERT(a_entry_static_inv);
else BOOST_CONTRACT_ASSERT(a_exit_static_inv);
a_entering_static_inv = false;
}
#endif
#ifndef BOOST_CONTRACT_TEST_NO_A_INV
void invariant() const {
out << "a::inv" << std::endl;
if(a_entering_inv) BOOST_CONTRACT_ASSERT(a_entry_inv);
else BOOST_CONTRACT_ASSERT(a_exit_inv);
a_entering_inv = false;
}
#endif
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
#ifndef BOOST_CONTRACT_TEST_NO_A_PRE
.precondition([] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(a_pre);
})
#endif
.old([] { out << "a::f::old" << std::endl; })
#ifndef BOOST_CONTRACT_TEST_NO_A_POST
.postcondition([] {
out << "a::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(a_post);
})
#endif
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
#endif // #include guard

185
libs/contract/test/public_function/decl_entry_inv_all.cpp Normal file
View File

@@ -0,0 +1,185 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with entry invariants.
#undef BOOST_CONTRACT_TEST_NO_A_INV
#undef BOOST_CONTRACT_TEST_NO_B_INV
#undef BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_inv = false;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = false;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = false;
b_entry_inv = false;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed (as all did).
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

179
libs/contract/test/public_function/decl_entry_inv_ends.cpp Normal file
View File

@@ -0,0 +1,179 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with entry invariants.
#undef BOOST_CONTRACT_TEST_NO_A_INV
#define BOOST_CONTRACT_TEST_NO_B_INV
#undef BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_inv = false;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = false;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = false;
b_entry_inv = false;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed (as all did).
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

172
libs/contract/test/public_function/decl_entry_inv_mid.cpp Normal file
View File

@@ -0,0 +1,172 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with entry invariants.
#define BOOST_CONTRACT_TEST_NO_A_INV
#undef BOOST_CONTRACT_TEST_NO_B_INV
#define BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_inv = false;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = false;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this fail.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_inv = false;
b_entry_inv = false;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this failed (as all did).
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

105
libs/contract/test/public_function/decl_entry_inv_none.cpp Normal file
View File

@@ -0,0 +1,105 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without entry invariants.
#define BOOST_CONTRACT_TEST_NO_A_INV
#define BOOST_CONTRACT_TEST_NO_B_INV
#define BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
ok.str(""); ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_inv = false;
b_entry_inv = true;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_inv = true;
b_entry_inv = false;
c_entry_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_inv = true;
b_entry_inv = true;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_inv = false;
b_entry_inv = false;
c_entry_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

183
libs/contract/test/public_function/decl_entry_static_inv_all.cpp Normal file
View File

@@ -0,0 +1,183 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with entry static invariants.
#undef BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_static_inv = false;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = false;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = false;
b_entry_static_inv = false;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
// Test this failed (as all did).
<< "c::static_inv" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

198
libs/contract/test/public_function/decl_entry_static_inv_ends.cpp Normal file
View File

@@ -0,0 +1,198 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with entry static inv.
#undef BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_static_inv = false;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = false;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =true;
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl // Test this failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = false;
b_entry_static_inv = false;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
// Test this failed (as all did).
<< "c::static_inv" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

169
libs/contract/test/public_function/decl_entry_static_inv_mid.cpp Normal file
View File

@@ -0,0 +1,169 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with entry static invariants.
#define BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_entry_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_entry_static_inv = false;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =true;
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = false;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl // Test this fail.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =true;
out.str("");
try {
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_entry_static_inv = false;
b_entry_static_inv = false;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
// Test this failed (as all did).
<< "b::static_inv" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

104
libs/contract/test/public_function/decl_entry_static_inv_none.cpp Normal file
View File

@@ -0,0 +1,104 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without entry static invariants.
#define BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok; ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_static_inv = false;
b_entry_static_inv = true;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_static_inv = true;
b_entry_static_inv = false;
c_entry_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_static_inv = true;
b_entry_static_inv = true;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_entry_static_inv = false;
b_entry_static_inv = false;
c_entry_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

196
libs/contract/test/public_function/decl_exit_inv_all.cpp Normal file
View File

@@ -0,0 +1,196 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with exit invariants.
#undef BOOST_CONTRACT_TEST_NO_A_INV
#undef BOOST_CONTRACT_TEST_NO_B_INV
#undef BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_inv = false;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = false;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = false;
b_exit_inv = false;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed (as all did).
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

189
libs/contract/test/public_function/decl_exit_inv_ends.cpp Normal file
View File

@@ -0,0 +1,189 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with exit invariants.
#undef BOOST_CONTRACT_TEST_NO_A_INV
#define BOOST_CONTRACT_TEST_NO_B_INV
#undef BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_inv = false;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = false;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = false;
b_exit_inv = false;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl // Test this failed (as all did).
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

187
libs/contract/test/public_function/decl_exit_inv_mid.cpp Normal file
View File

@@ -0,0 +1,187 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with exit invariants.
#define BOOST_CONTRACT_TEST_NO_A_INV
#undef BOOST_CONTRACT_TEST_NO_B_INV
#define BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_inv = false;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
// Test no failure here.
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = false;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_inv = false;
b_exit_inv = false;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl // Test this failed (as all did).
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

110
libs/contract/test/public_function/decl_exit_inv_none.cpp Normal file
View File

@@ -0,0 +1,110 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without exit invariants.
#define BOOST_CONTRACT_TEST_NO_A_INV
#define BOOST_CONTRACT_TEST_NO_B_INV
#define BOOST_CONTRACT_TEST_NO_C_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
ok.str(""); ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
// No invariants.
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "b::static_inv" << std::endl
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a aa;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_inv = false;
b_exit_inv = true;
c_exit_inv = true;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_inv = true;
b_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_inv = true;
b_exit_inv = true;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_inv = false;
b_exit_inv = false;
c_exit_inv = false;
a_entering_inv = b_entering_inv = c_entering_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

195
libs/contract/test/public_function/decl_exit_static_inv_all.cpp Normal file
View File

@@ -0,0 +1,195 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with exit static invariants.
#undef BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_static_inv = false;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = false;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = false;
b_exit_static_inv = false;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
// Test this failed (as all did).
<< "c::static_inv" << std::endl
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

191
libs/contract/test/public_function/decl_exit_static_inv_ends.cpp Normal file
View File

@@ -0,0 +1,191 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with exit static invariants.
#undef BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_static_inv = false;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = false;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
// Test no failure here.
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = false;
b_exit_static_inv = false;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
// Test this failed (as all did).
<< "c::static_inv" << std::endl
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

190
libs/contract/test/public_function/decl_exit_static_inv_mid.cpp Normal file
View File

@@ -0,0 +1,190 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with exit static invariants.
#define BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#undef BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
a_exit_static_inv = false;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
// Test no failure here.
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = false;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl // Test this failed.
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
// Test no failure here.
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_exit_static_inv = false;
b_exit_static_inv = false;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
// Test this failed (as all did).
<< "b::static_inv" << std::endl
#elif !defined(BOOST_CONTRACT_NO_POSTCONDITIONS)
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

110
libs/contract/test/public_function/decl_exit_static_inv_none.cpp Normal file
View File

@@ -0,0 +1,110 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without exit static invariants.
#define BOOST_CONTRACT_TEST_NO_A_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_B_STATIC_INV
#define BOOST_CONTRACT_TEST_NO_C_STATIC_INV
#include "decl.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok; ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
// No static invariants.
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
boost::contract::set_exit_invariant_failure(
[] (boost::contract::from) { throw err(); });
#ifdef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 0
#else
#define BOOST_CONTRACT_TEST_entry_inv 1
#endif
a aa;
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_static_inv = false;
b_exit_static_inv = true;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_static_inv = true;
b_exit_static_inv = false;
c_exit_static_inv = true;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_static_inv = true;
b_exit_static_inv = true;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_exit_static_inv = false;
b_exit_static_inv = false;
c_exit_static_inv = false;
a_entering_static_inv = b_entering_static_inv = c_entering_static_inv =
BOOST_PP_IIF(BOOST_CONTRACT_TEST_entry_inv, true, false);
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
#undef BOOST_CONTRACT_TEST_entry_inv
return boost::report_errors();
}

163
libs/contract/test/public_function/decl_post_all.cpp Normal file
View File

@@ -0,0 +1,163 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with postconditions.
#undef BOOST_CONTRACT_TEST_NO_A_POST
#undef BOOST_CONTRACT_TEST_NO_B_POST
#undef BOOST_CONTRACT_TEST_NO_C_POST
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_post = true;
b_post = true;
c_post = true;
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_postcondition_failure(
[] (boost::contract::from) { throw err(); });
a_post = false;
b_post = true;
c_post = true;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = false;
c_post = true;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = true;
c_post = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = false;
b_post = false;
c_post = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl // Test this failed (as all did).
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

158
libs/contract/test/public_function/decl_post_ends.cpp Normal file
View File

@@ -0,0 +1,158 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with postconditions.
#undef BOOST_CONTRACT_TEST_NO_A_POST
#define BOOST_CONTRACT_TEST_NO_B_POST
#undef BOOST_CONTRACT_TEST_NO_C_POST
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_post = true;
b_post = true;
c_post = true;
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_postcondition_failure(
[] (boost::contract::from) { throw err(); });
a_post = false;
b_post = true;
c_post = true;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "a::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = false;
c_post = true;
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
// Test no failure here.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = true;
c_post = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = false;
b_post = false;
c_post = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl // Test this failed (as all did).
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

154
libs/contract/test/public_function/decl_post_mid.cpp Normal file
View File

@@ -0,0 +1,154 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with postconditions.
#define BOOST_CONTRACT_TEST_NO_A_POST
#undef BOOST_CONTRACT_TEST_NO_B_POST
#define BOOST_CONTRACT_TEST_NO_C_POST
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_post = true;
b_post = true;
c_post = true;
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_postcondition_failure(
[] (boost::contract::from) { throw err(); });
a_post = false;
b_post = true;
c_post = true;
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
// Test no failure here.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = false;
c_post = true;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl // Test this failed.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = true;
b_post = true;
c_post = false;
out.str("");
try {
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
// Test no failure here.
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_post = false;
b_post = false;
c_post = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl // Test this failed (as all did).
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

90
libs/contract/test/public_function/decl_post_none.cpp Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without postconditions.
#define BOOST_CONTRACT_TEST_NO_A_POST
#define BOOST_CONTRACT_TEST_NO_B_POST
#define BOOST_CONTRACT_TEST_NO_C_POST
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok; ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No postconditions.
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
#endif
;
a aa;
a_post = true;
b_post = true;
c_post = true;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_post = false;
b_post = true;
c_post = true;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_post = true;
b_post = false;
c_post = true;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_post = true;
b_post = true;
c_post = false;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_post = false;
b_post = false;
c_post = false;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

154
libs/contract/test/public_function/decl_pre_all.cpp Normal file
View File

@@ -0,0 +1,154 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes with preconditions.
#undef BOOST_CONTRACT_TEST_NO_A_PRE
#undef BOOST_CONTRACT_TEST_NO_B_PRE
#undef BOOST_CONTRACT_TEST_NO_C_PRE
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl // Old only if post (or except) run.
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_pre = true;
b_pre = true;
c_pre = true;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl // Test only c::f::pre checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = true;
b_pre = false;
c_pre = false;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl // Test all pre checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = true;
c_pre = false;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
// Test only a::f::pre not checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = false;
c_pre = true;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl // Test only c::f::pre checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_precondition_failure(
[] (boost::contract::from) { throw err(); });
a_pre = false;
b_pre = false;
c_pre = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl // Test all pre checked and failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

159
libs/contract/test/public_function/decl_pre_ends.cpp Normal file
View File

@@ -0,0 +1,159 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only derived and grandparent classes (ends) with preconditions.
#undef BOOST_CONTRACT_TEST_NO_A_PRE
#define BOOST_CONTRACT_TEST_NO_B_PRE
#undef BOOST_CONTRACT_TEST_NO_C_PRE
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl // Old only if post (or except) run.
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_pre = true;
b_pre = true;
c_pre = true;
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl // Test only c pre checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = true;
b_pre = false;
c_pre = false;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
// Test b's pre not checked.
<< "a::f::pre" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = false;
c_pre = true;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl // Test only c pre checked.
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_precondition_failure(
[] (boost::contract::from) { throw err(); });
a_pre = false;
b_pre = true;
c_pre = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "a::f::pre" << std::endl // Only ends pre checked and failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_pre = false;
b_pre = false;
c_pre = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "a::f::pre" << std::endl // Only ends pre checked and failed.
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

166
libs/contract/test/public_function/decl_pre_mid.cpp Normal file
View File

@@ -0,0 +1,166 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test only middle base class with preconditions.
#define BOOST_CONTRACT_TEST_NO_A_PRE
#undef BOOST_CONTRACT_TEST_NO_B_PRE
#define BOOST_CONTRACT_TEST_NO_C_PRE
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
std::string ok_begin() {
std::ostringstream ok; ok << "" // Suppress a warning.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
;
return ok.str();
}
std::string ok_end() {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl // Old only if post (or except) run.
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
return ok.str();
}
struct err {}; // Global decl so visible in MSVC10 lambdas.
int main() {
std::ostringstream ok;
a aa;
a_pre = true;
b_pre = true;
c_pre = true;
out.str("");
aa.f();
ok.str(""); ok // Test nothing failed.
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = true;
c_pre = false;
out.str("");
aa.f();
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
// Test only middle pre checked and no fail.
<< "b::f::pre" << std::endl
#endif
<< ok_end()
;
BOOST_TEST(out.eq(ok.str()));
boost::contract::set_precondition_failure(
[] (boost::contract::from) { throw err(); });
a_pre = true;
b_pre = false;
c_pre = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
// Test only middle pre checked and failed.
<< "b::f::pre" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_pre = false;
b_pre = false;
c_pre = true;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
// Test only middle pre checked and failed.
<< "b::f::pre" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
a_pre = false;
b_pre = false;
c_pre = false;
out.str("");
try {
aa.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(err const&) {
#endif
ok.str(""); ok
<< ok_begin()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
// Test only middle pre checked and failed.
<< "b::f::pre" << std::endl
#else
<< ok_end()
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

90
libs/contract/test/public_function/decl_pre_none.cpp Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test all derived and base classes without preconditions.
#define BOOST_CONTRACT_TEST_NO_A_PRE
#define BOOST_CONTRACT_TEST_NO_B_PRE
#define BOOST_CONTRACT_TEST_NO_C_PRE
#include "decl.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok; ok // Test nothing fails.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
// No preconditions here.
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl // Old only if post (or except) run.
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
a aa;
a_pre = true;
b_pre = true;
c_pre = true;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_pre = true;
b_pre = false;
c_pre = false;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = true;
c_pre = false;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = false;
c_pre = true;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
a_pre = false;
b_pre = false;
c_pre = false;
out.str("");
aa.f();
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

107
libs/contract/test/public_function/friend.cpp Normal file
View File

@@ -0,0 +1,107 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test friend functions (also forcing them to check invariants).
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/function.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/assert.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
class y;
class z;
class x {
public:
void invariant() const {
out << "x::inv" << std::endl;
BOOST_CONTRACT_ASSERT(get() >= 0);
}
x() : value_(0) {}
int get() const { return value_; }
friend void f(x&, y&, int value);
private:
int value_;
};
class y {
public:
void invariant() const {
out << "y::inv" << std::endl;
BOOST_CONTRACT_ASSERT(get() >= 0);
}
y() : value_(0) {}
int get() const { return value_; }
friend void f(x&, y&, int value);
private:
int value_;
};
void f(x& a, y& b, int value) {
boost::contract::check post = boost::contract::function()
.postcondition([&] {
out << "f::post" << std::endl;
BOOST_CONTRACT_ASSERT(a.get() == value);
BOOST_CONTRACT_ASSERT(b.get() == value);
})
;
boost::contract::check inv_b = boost::contract::public_function(&b);
boost::contract::check inv_a = boost::contract::public_function(&a);
boost::contract::check pre = boost::contract::function()
.precondition([&] {
out << "f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(value > 0);
})
;
out << "f::body" << std::endl;
a.value_ = b.value_ = value;
}
int main() {
std::ostringstream ok;
x a;
y b;
out.str("");
f(a, b, 123);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "y::inv" << std::endl
<< "x::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "f::pre" << std::endl
#endif
<< "f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "x::inv" << std::endl
<< "y::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
BOOST_TEST_EQ(a.get(), 123);
BOOST_TEST_EQ(b.get(), 123);
return boost::report_errors();
}

122
libs/contract/test/public_function/ifdef.cpp Normal file
View File

@@ -0,0 +1,122 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test contract compilation on/off.
#include "../detail/oteststream.hpp"
#include <boost/contract/core/config.hpp>
#include <boost/contract/core/virtual.hpp>
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/old.hpp>
#endif
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct b {
#ifndef BOOST_CONTRACT_NO_INVARIANTS
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
#endif
virtual void f(int x, boost::contract::virtual_* v = 0) = 0;
};
void b::f(int x, boost::contract::virtual_* v) {
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
boost::contract::old_ptr<int> old_x = BOOST_CONTRACT_OLDOF(v, x);
#endif
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
boost::contract::check c = boost::contract::public_function(v, this)
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
.precondition([] { out << "b::f::pre" << std::endl; })
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
#endif
;
#endif
out << "b::f::body" << std::endl;
}
struct a
#define BASES public b
: BASES
{
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
BOOST_CONTRACT_OVERRIDE(f)
#endif
#ifndef BOOST_CONTRACT_NO_INVARIANTS
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
#endif
virtual void f(int x, boost::contract::virtual_* v = 0) {
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
boost::contract::old_ptr<int> old_x = BOOST_CONTRACT_OLDOF(v, x);
#endif
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
boost::contract::check c = boost::contract::public_function<
override_f>(v, &a::f, this, x)
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
.precondition([] { out << "a::f::pre" << std::endl; })
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
#endif
;
#endif
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f(123);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

171
libs/contract/test/public_function/ifdef_macro.cpp Normal file
View File

@@ -0,0 +1,171 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test contract compilation on/off (using macro interface).
#include "../detail/oteststream.hpp"
#include "../detail/unprotected_commas.hpp"
#include <boost/contract/core/config.hpp>
#include <boost/contract/core/virtual.hpp>
#include <boost/contract_macro.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct b {
BOOST_CONTRACT_STATIC_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "b::static_inv" << std::endl;
})
BOOST_CONTRACT_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "b::inv" << std::endl;
})
virtual void f(int x, boost::contract::virtual_* v = 0) = 0;
};
void b::f(int x, boost::contract::virtual_* v) {
BOOST_CONTRACT_OLD_PTR(
boost::contract::test::detail::unprotected_commas<int, void, void>::
type1
)(
(boost::contract::test::detail::unprotected_commas<void, void, void>::
same(v)),
old_x,
(boost::contract::test::detail::unprotected_commas<void, void, void>::
same(x))
);
BOOST_CONTRACT_PUBLIC_FUNCTION(
boost::contract::test::detail::unprotected_commas<void, void, void>::
same(v),
boost::contract::test::detail::unprotected_commas<void, void, void>::
same(this)
)
BOOST_CONTRACT_PRECONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "b::f::pre" << std::endl;
})
BOOST_CONTRACT_OLD([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "b::f::old" << std::endl;
})
BOOST_CONTRACT_POSTCONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "b::f::post" << std::endl;
})
;
out << "b::f::body" << std::endl;
}
struct a
#define BASES public boost::contract::test::detail::unprotected_commas< \
b, void, void>::type1
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
BOOST_CONTRACT_OVERRIDE(f)
BOOST_CONTRACT_STATIC_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "a::static_inv" << std::endl;
})
BOOST_CONTRACT_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "a::inv" << std::endl;
})
virtual void f(int x, boost::contract::virtual_* v = 0) {
BOOST_CONTRACT_OLD_PTR(
boost::contract::test::detail::unprotected_commas<int, void, void>::
type1
)(
(boost::contract::test::detail::unprotected_commas<void, void,
void>::same(v)),
old_x,
(boost::contract::test::detail::unprotected_commas<void, void,
void>::same(x))
);
BOOST_CONTRACT_PUBLIC_FUNCTION_OVERRIDE(
boost::contract::test::detail::unprotected_commas<override_f, void,
void>::type1
)(
boost::contract::test::detail::unprotected_commas<void, void, void>
::same(v),
&a::f,
boost::contract::test::detail::unprotected_commas<void, void, void>
::same(this),
boost::contract::test::detail::unprotected_commas<void, void, void>
::same(x)
)
BOOST_CONTRACT_PRECONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::pre" << std::endl;
})
BOOST_CONTRACT_OLD([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::old" << std::endl;
})
BOOST_CONTRACT_POSTCONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::post" << std::endl;
})
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f(123);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl // Called by post (so under NO_POST).
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

10
libs/contract/test/public_function/max_args.cpp Normal file
View File

@@ -0,0 +1,10 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with default max argument number (leave MAX_ARGS #undef).
#include "max_args.hpp"

209
libs/contract/test/public_function/max_args.hpp Normal file
View File

@@ -0,0 +1,209 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test max argument number for public function (with and without result).
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/arithmetic/inc.hpp>
#include <boost/preprocessor/control/expr_iif.hpp>
#include <boost/preprocessor/cat.hpp>
#include <boost/preprocessor/stringize.hpp>
#include <boost/config.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
#if defined(BOOST_GCC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter" // aN from macros.
#elif defined(BOOST_CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-parameter" // aN from macros.
#endif
#define BOOST_CONTRACT_TEST_MAX_ARGS_PARAM_COMMA_(z, n, unused) \
int BOOST_PP_CAT(a, n) ,
#define BOOST_CONTRACT_TEST_MAX_ARGS_COMMA_ARG_(z, n, unused) \
, BOOST_PP_CAT(a, n)
#define BOOST_CONTRACT_TEST_MAX_ARGS_N_(z, n, unused) \
n
struct b {
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
#define BOOST_CONTRACT_TEST_MAX_ARGS_B_F_(z, n, unused) \
virtual int BOOST_PP_CAT(f, n)( \
BOOST_PP_REPEAT_ ## z( \
n, BOOST_CONTRACT_TEST_MAX_ARGS_PARAM_COMMA_, ~) \
boost::contract::virtual_* v = 0 \
) { \
int result = 0; \
boost::contract::check c = boost::contract::public_function( \
v, result, this) \
.precondition([] { \
out << "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::pre" << std::endl; \
}) \
.old([] { \
out << "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::old" << std::endl; \
}) \
.postcondition([] (int result) { \
out << "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::post" << std::endl; \
}) \
; \
out << "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::body" << std::endl; \
return result; \
}
BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_CONTRACT_MAX_ARGS),
BOOST_CONTRACT_TEST_MAX_ARGS_B_F_, ~)
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
#define BOOST_CONTRACT_TEST_MAX_ARGS_A_F_(z, n, unused) \
int BOOST_PP_CAT(f, n)( \
BOOST_PP_REPEAT_ ## z( \
n, BOOST_CONTRACT_TEST_MAX_ARGS_PARAM_COMMA_, ~) \
boost::contract::virtual_* v = 0 \
) /* override */ { \
int result = 0; \
boost::contract::check c = boost::contract::public_function< \
BOOST_PP_CAT(override_, BOOST_PP_CAT(f, n)) \
>( \
v, result, &a::BOOST_PP_CAT(f, n), this \
BOOST_PP_REPEAT_ ## z( \
n, BOOST_CONTRACT_TEST_MAX_ARGS_COMMA_ARG_, ~) \
) \
.precondition([] { \
out << "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::pre" << std::endl; \
}) \
.old([] { \
out << "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::old" << std::endl; \
}) \
.postcondition([] (int result) { \
out << "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::post" << std::endl; \
}) \
; \
out << "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::body" << std::endl; \
return result; \
} \
BOOST_CONTRACT_OVERRIDE(BOOST_PP_CAT(f, n))
BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_CONTRACT_MAX_ARGS),
BOOST_CONTRACT_TEST_MAX_ARGS_A_F_, ~)
};
#if defined(BOOST_GCC)
#pragma GCC diagnostic pop
#elif defined(BOOST_CLANG)
#pragma clang diagnostic pop
#endif
int main() {
std::ostringstream ok;
a aa;
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
#define BOOST_CONTRACT_TEST_entry_inv 1
#else
#define BOOST_CONTRACT_TEST_entry_inv 0
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
#define BOOST_CONTRACT_TEST_pre 1
#else
#define BOOST_CONTRACT_TEST_pre 0
#endif
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
#define BOOST_CONTRACT_TEST_exit_inv 1
#else
#define BOOST_CONTRACT_TEST_exit_inv 0
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
#define BOOST_CONTRACT_TEST_post 1
#else
#define BOOST_CONTRACT_TEST_post 0
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1
#else
#define BOOST_CONTRACT_TEST_old 0
#endif
#define BOOST_CONTRACT_TEST_MAX_ARGS_TEST_(z, n, unused) \
out.str(""); \
aa.BOOST_PP_CAT(f, n)(BOOST_PP_ENUM_ ## z( \
n, BOOST_CONTRACT_TEST_MAX_ARGS_N_, ~)); \
ok.str(""); ok \
BOOST_PP_EXPR_IIF(BOOST_CONTRACT_TEST_entry_inv, \
<< "b::static_inv\n" \
<< "b::inv\n"\
<< "a::static_inv\n" \
<< "a::inv\n" \
) \
BOOST_PP_EXPR_IIF(BOOST_CONTRACT_TEST_pre, \
<< "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::pre\n" \
) \
BOOST_PP_EXPR_IIF(BOOST_CONTRACT_TEST_old, \
<< "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::old\n" \
<< "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::old\n" \
) \
<< "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << "::body\n" \
BOOST_PP_EXPR_IIF(BOOST_CONTRACT_TEST_exit_inv, \
<< "b::static_inv\n" \
<< "b::inv\n"\
<< "a::static_inv\n" \
<< "a::inv\n" \
) \
BOOST_PP_EXPR_IIF(BOOST_CONTRACT_TEST_post, \
<< "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::old\n" \
<< "b::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::post\n" \
<< "a::" << BOOST_PP_STRINGIZE(BOOST_PP_CAT(f, n)) << \
"::post\n" \
) \
; \
BOOST_TEST(out.eq(ok.str()));
BOOST_PP_REPEAT(BOOST_PP_INC(BOOST_CONTRACT_MAX_ARGS),
BOOST_CONTRACT_TEST_MAX_ARGS_TEST_, ~)
#undef BOOST_CONTRACT_TEST_entry_inv
#undef BOOST_CONTRACT_TEST_pre
#undef BOOST_CONTRACT_TEST_exit_inv
#undef BOOST_CONTRACT_TEST_post
#undef BOOST_CONTRACT_TEST_old
return boost::report_errors();
}

13
libs/contract/test/public_function/max_args0.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 0.
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 0
#error "build must define MAX_ARGS=0"
#endif
#include "max_args.hpp"

16
libs/contract/test/public_function/max_args0_no_tva.cpp Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 0 and no variadic templates.
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "build must define BOOST_NO_CXX11_VARIADIC_TEMPLATES"
#endif
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 0
#error "build must define MAX_ARGS=0"
#endif
#include "max_args.hpp"

13
libs/contract/test/public_function/max_args1.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 1.
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 1
#error "build must define MAX_ARGS=1"
#endif
#include "max_args.hpp"

16
libs/contract/test/public_function/max_args1_no_tva.cpp Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 1 and no variadic templates.
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "build must define BOOST_NO_CXX11_VARIADIC_TEMPLATES"
#endif
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 1
#error "build must define MAX_ARGS=1"
#endif
#include "max_args.hpp"

13
libs/contract/test/public_function/max_args2.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 2.
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 2
#error "build must define MAX_ARGS=2"
#endif
#include "max_args.hpp"

16
libs/contract/test/public_function/max_args2_no_tva.cpp Normal file
View File

@@ -0,0 +1,16 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max argument number set to 2 and no variadic templates.
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "build must define BOOST_NO_CXX11_VARIADIC_TEMPLATES"
#endif
#if !defined(BOOST_CONTRACT_MAX_ARGS) || BOOST_CONTRACT_MAX_ARGS != 2
#error "build must define MAX_ARGS=2"
#endif
#include "max_args.hpp"

13
libs/contract/test/public_function/max_args_no_tva.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with default max arg number (leave MAX_ARGS #undef) and no variadic tpl.
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "build must define BOOST_NO_CXX11_VARIADIC_TEMPLATES"
#endif
#include "max_args.hpp"

59
libs/contract/test/public_function/max_bases.cpp Normal file
View File

@@ -0,0 +1,59 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test with max possible number of bases.
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/override.hpp>
#include <boost/preprocessor/repetition/repeat.hpp>
#include <boost/preprocessor/repetition/enum.hpp>
#include <boost/preprocessor/cat.hpp>
// Limited by max size of current impl of Boost.MPL vector.
#ifndef BOOST_CONTRACT_TEST_CONFIG_MAX_BASES
#define BOOST_CONTRACT_TEST_CONFIG_MAX_BASES 20
#endif
#define BOOST_CONTRACT_TEST_base_decl(z, n, unused) \
struct BOOST_PP_CAT(b, n) { \
virtual void f(boost::contract::virtual_* v = 0) { \
boost::contract::check c = boost::contract::public_function( \
v, this); \
} \
};
BOOST_PP_REPEAT(BOOST_CONTRACT_TEST_CONFIG_MAX_BASES,
BOOST_CONTRACT_TEST_base_decl, ~)
#define BOOST_CONTRACT_TEST_public_base(z, n, unused) public BOOST_PP_CAT(b, n)
struct a
#define BASES \
BOOST_PP_ENUM(BOOST_CONTRACT_TEST_CONFIG_MAX_BASES, \
BOOST_CONTRACT_TEST_public_base, ~)
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this);
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
a aa;
aa.f();
return 0;
}
#undef BOOST_CONTRACT_TEST_base_decl
#undef BOOST_CONTRACT_TEST_public_base

214
libs/contract/test/public_function/old_virtual.cpp Normal file
View File

@@ -0,0 +1,214 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test old inits/ftors and of mixed types up inheritance tree.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/old.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/override.hpp>
#include <boost/lexical_cast.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
boost::contract::test::detail::oteststream out;
struct num {
static num make(int i) { // Test no ctor (not even explicit) but for copy.
num n;
n.value(i);
return n;
}
num(num const& other) : value_(other.value_) {}
void value(int i) { value_ = boost::lexical_cast<std::string>(i); }
int value() const { return boost::lexical_cast<int>(value_); }
num operator+(int left) {
num n;
n.value(value() + left);
return n;
}
private:
num() {} // Test no visible default ctor (only copy ctor).
num& operator=(num const&); // Test no copy operator (only copy ctor).
std::string value_; // Test this size-of != from other old type `int` below.
};
struct c {
virtual void f(int& i, num& n, boost::contract::virtual_* v = 0) {
boost::contract::old_ptr<int> old_a = BOOST_CONTRACT_OLDOF(v, i + 1);
boost::contract::old_ptr<num> old_b = BOOST_CONTRACT_OLDOF(v, n + 2);
boost::contract::old_ptr<int> old_x;
boost::contract::old_ptr<num> old_y;
boost::contract::check c = boost::contract::public_function(v, this)
.old([&] {
out << "c::f::old" << std::endl;
old_x = BOOST_CONTRACT_OLDOF(v, i + 3);
old_y = BOOST_CONTRACT_OLDOF(v, n + 4);
})
.postcondition([&] {
out << "c::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(*old_a == n.value() + 1);
BOOST_CONTRACT_ASSERT(old_b->value() == i + 2);
BOOST_CONTRACT_ASSERT(*old_x == n.value() + 3);
BOOST_CONTRACT_ASSERT(old_y->value() == i + 4);
})
;
out << "c::f::body" << std::endl;
int tmp = i;
i = n.value();
n.value(tmp);
}
};
struct b
#define BASES public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
virtual void f(int& i, num& n, boost::contract::virtual_* v = 0)
/* override */ {
boost::contract::old_ptr<int> old_a = BOOST_CONTRACT_OLDOF(v, i + 1);
boost::contract::old_ptr<num> old_b = BOOST_CONTRACT_OLDOF(v, n + 2);
boost::contract::old_ptr<int> old_x;
boost::contract::old_ptr<num> old_y;
boost::contract::check c = boost::contract::public_function<
override_f>(v, &c::f, this, i, n)
.old([&] {
out << "b::f::old" << std::endl;
old_x = BOOST_CONTRACT_OLDOF(v, i + 3);
old_y = BOOST_CONTRACT_OLDOF(v, n + 4);
})
.postcondition([&] {
out << "b::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(*old_a == n.value() + 1);
BOOST_CONTRACT_ASSERT(old_b->value() == i + 2);
BOOST_CONTRACT_ASSERT(*old_x == n.value() + 3);
BOOST_CONTRACT_ASSERT(old_y->value() == i + 4);
})
;
out << "b::f::body" << std::endl;
int tmp = i;
i = n.value();
n.value(tmp);
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
virtual void f(int& i, num& n, boost::contract::virtual_* v = 0)
/* override */ {
boost::contract::old_ptr<int> old_a = BOOST_CONTRACT_OLDOF(v, i + 1);
boost::contract::old_ptr<num> old_b = BOOST_CONTRACT_OLDOF(v, n + 2);
boost::contract::old_ptr<int> old_x;
boost::contract::old_ptr<num> old_y;
boost::contract::check c = boost::contract::public_function<
override_f>(v, &c::f, this, i, n)
.old([&] {
out << "a::f::old" << std::endl;
old_x = BOOST_CONTRACT_OLDOF(v, i + 3);
old_y = BOOST_CONTRACT_OLDOF(v, n + 4);
})
.postcondition([&] {
out << "a::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(*old_a == n.value() + 1);
BOOST_CONTRACT_ASSERT(old_b->value() == i + 2);
BOOST_CONTRACT_ASSERT(*old_x == n.value() + 3);
BOOST_CONTRACT_ASSERT(old_y->value() == i + 4);
})
;
out << "a::f::body" << std::endl;
int tmp = i;
i = n.value();
n.value(tmp);
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
std::ostringstream ok;
int i = 0;
num n = num::make(0);
i = 123;
n.value(-123);
a aa; // Test virtual call with 2 bases.
out.str("");
aa.f(i, n);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
i = 456;
n.value(-456);
b bb; // Test virtual call with 1 base.
out.str("");
bb.f(i, n);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
#endif
<< "b::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
// No old call here because not a base object.
<< "b::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
i = 789;
n.value(-789);
c cc; // Test virtual call with no bases.
out.str("");
cc.f(i, n);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
#endif
<< "c::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not a base object.
<< "c::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

10
libs/contract/test/public_function/overload.cpp Normal file
View File

@@ -0,0 +1,10 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public function overloads (with variadic templates if supported).
#include "overload.hpp"

343
libs/contract/test/public_function/overload.hpp Normal file
View File

@@ -0,0 +1,343 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public function overloads.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
#include <string>
boost::contract::test::detail::oteststream out;
struct b {
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(int /* x */, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f(int)::pre" << std::endl; })
.old([] { out << "b::f(int)::old" << std::endl; })
.postcondition([] { out << "b::f(int)::post" << std::endl; })
;
out << "b::f(int)::body" << std::endl;
}
virtual void f(char const* /* x */, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f(char const*)::pre" << std::endl; })
.old([] { out << "b::f(char const*)::old" << std::endl; })
.postcondition(
[] { out << "b::f(char const*)::post" << std::endl; })
;
out << "b::f(char const*)::body" << std::endl;
}
virtual void f(int /* x */, int /* y */, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f(int, int)::pre" << std::endl; })
.old([] { out << "b::f(int, int)::old" << std::endl; })
.postcondition([] { out << "b::f(int, int)::post" << std::endl; })
;
out << "b::f(int, int)::body" << std::endl;
}
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f()::pre" << std::endl; })
.old([] { out << "b::f()::old" << std::endl; })
.postcondition([] { out << "b::f()::post" << std::endl; })
;
out << "b::f()::body" << std::endl;
}
void f(int /* x */[2][3], boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f(int[2][3])::pre" << std::endl; })
.old([] { out << "b::f(int[2][3])::old" << std::endl; })
.postcondition([] { out << "b::f(int[2][3])::post" << std::endl; })
;
out << "b::f(int[2][3])::body" << std::endl;
}
void f(void (* /* x */)(int), boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition(
[] { out << "b::f(void (*)(int))::pre" << std::endl; })
.old(
[] { out << "b::f(void (*)(int))::old" << std::endl; })
.postcondition(
[] { out << "b::f(void (*)(int))::post" << std::endl; })
;
out << "b::f(void (*)(int))::body" << std::endl;
}
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
void f(int x, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v,
static_cast<void (a::*)(int, boost::contract::virtual_*)>(&a::f),
this, x
)
.precondition([] { out << "a::f(int)::pre" << std::endl; })
.old([] { out << "a::f(int)::old" << std::endl; })
.postcondition([] { out << "a::f(int)::post" << std::endl; })
;
out << "a::f(int)::body" << std::endl;
}
// Test overload via argument type.
void f(char const* x, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v,
static_cast<void (a::*)(char const*, boost::contract::virtual_*)>(
&a::f),
this, x
)
.precondition([] { out << "a::f(char const*)::pre" << std::endl; })
.old([] { out << "a::f(char const*)::old" << std::endl; })
.postcondition(
[] { out << "a::f(char const*)::post" << std::endl; })
;
out << "a::f(char const*)::body" << std::endl;
}
// Test overload via argument count.
void f(int x, int y, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v,
static_cast<void (a::*)(int, int, boost::contract::virtual_*)>(
&a::f),
this, x, y
)
.precondition([] { out << "a::f(int, int)::pre" << std::endl; })
.old([] { out << "a::f(int, int)::old" << std::endl; })
.postcondition([] { out << "a::f(int, int)::post" << std::endl; })
;
out << "a::f(int, int)::body" << std::endl;
}
// Test overload via template argument type.
template<typename T>
void f(T /* x */) { // Template cannot be virtual (or override) in C++.
boost::contract::check c = boost::contract::public_function(this)
.precondition([] { out << "a::f(T)::pre" << std::endl; })
.old([] { out << "a::f(T)::old" << std::endl; })
.postcondition([] { out << "a::f(T)::post" << std::endl; })
;
out << "a::f(T)::body" << std::endl;
}
// Test no overload ambiguity in public_function called by these two cases.
// NOTE: In *all* other cases, public_function is always called with a
// different number of arguments so there cannot be ambiguity either
// (0 args for static, 1 arg for non-virtual, 2 or 3 args for virtual,
// >= 3 for override, so only in cases below of 3 args for virtual and 3
// for override there could be ambiguity but there is not because of
// presence or absence of override_... template parameter).
typedef void (a::* f0_ptr)(boost::contract::virtual_*);
void f(boost::contract::virtual_* v = 0) /* override */ {
f0_ptr f0 = static_cast<f0_ptr>(&a::f);
// Test this and public_function call in func below both take same 3
// args but they are ambiguous because of presence override_f.
boost::contract::check c = boost::contract::public_function<override_f>(
v, f0, this)
.precondition([] { out << "a::f()::pre" << std::endl; })
.old([] { out << "a::f()::old" << std::endl; })
.postcondition([] { out << "a::f()::post" << std::endl; })
;
out << "a::f()::body" << std::endl;
}
virtual f0_ptr f(bool /* x */, boost::contract::virtual_* v = 0)
/* not an override */ {
f0_ptr f0 = static_cast<f0_ptr>(&a::f);
// Test this and public_function call in func above both take same 3
// args but they are ambiguous because of lack of override_f.
boost::contract::check c = boost::contract::public_function(
v, f0, this)
.precondition([] { out << "a::f(bool)::pre" << std::endl; })
.old([] { out << "a::f(bool)::old" << std::endl; })
.postcondition([] (f0_ptr const&) {
out << "a::f(bool)::post" << std::endl; })
;
out << "a::f(bool)::body" << std::endl;
return f0;
}
// Test overload with array parameter.
void f(int x[2][3], boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v,
static_cast<void (a::*)(int[2][3], boost::contract::virtual_*)>(
&a::f),
this, x
)
.precondition([] { out << "a::f(int[2][3])::pre" << std::endl; })
.old([] { out << "a::f(int[2][3])::old" << std::endl; })
.postcondition([] { out << "a::f(int[2][3])::post" << std::endl; })
;
out << "a::f(int[2][3])::body" << std::endl;
}
// Test overload with function pointer parameter.
void f(void (*x)(int), boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v,
static_cast<void (a::*)(void (*)(int), boost::contract::virtual_*)>(
&a::f),
this, x
)
.precondition(
[] { out << "a::f(void (*)(int))::pre" << std::endl; })
.old(
[] { out << "a::f(void (*)(int))::old" << std::endl; })
.postcondition(
[] { out << "a::f(void (*)(int))::post" << std::endl; })
;
out << "a::f(void (*)(int))::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
void g(int) {}
std::string ok_args(std::string const& args) {
std::ostringstream ok; ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f(" << args << ")::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f(" << args << ")::old" << std::endl
<< "a::f(" << args << ")::old" << std::endl
#endif
<< "a::f(" << args << ")::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f(" << args << ")::old" << std::endl
<< "b::f(" << args << ")::post" << std::endl
<< "a::f(" << args << ")::post" << std::endl
#endif
;
return ok.str();
}
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f(123);
ok.str(""); ok << ok_args("int");
BOOST_TEST(out.eq(ok.str()));
out.str("");
aa.f("abc");
ok.str(""); ok << ok_args("char const*");
BOOST_TEST(out.eq(ok.str()));
out.str("");
aa.f(123, 456);
ok.str(""); ok << ok_args("int, int");
BOOST_TEST(out.eq(ok.str()));
out.str("");
struct {} zz;
aa.f(zz); // Call template (so no override because no virtual).
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f(T)::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f(T)::old" << std::endl
#endif
<< "a::f(T)::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f(T)::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
out.str("");
aa.f();
ok.str(""); ok << ok_args("");
BOOST_TEST(out.eq(ok.str()));
out.str("");
aa.f(true); // This does not override (public_function ambiguity testing).
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f(bool)::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f(bool)::old" << std::endl
#endif
<< "a::f(bool)::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f(bool)::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
out.str("");
int i[2][3];
aa.f(i);
ok.str(""); ok << ok_args("int[2][3]");
BOOST_TEST(out.eq(ok.str()));
out.str("");
aa.f(&g);
ok.str(""); ok << ok_args("void (*)(int)");
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

13
libs/contract/test/public_function/overload_no_tva.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public function overloads (always without variadic templates).
#ifndef BOOST_NO_CXX11_VARIADIC_TEMPLATES
#error "build must define BOOST_NO_CXX11_VARIADIC_TEMPLATES"
#endif
#include "overload.hpp"

41
libs/contract/test/public_function/override.hpp Normal file
View File

@@ -0,0 +1,41 @@
// no #include guard
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test error if override func does not actually override (unless PERMISSIVE).
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
struct b {
virtual void g(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this);
}
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<
override_f>(v, &a::f, this);
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
a aa;
aa.f();
return 0;
}

14
libs/contract/test/public_function/override_error.cpp Normal file
View File

@@ -0,0 +1,14 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test error if override func does not actually override.
#undef BOOST_CONTRACT_PERMISSIVE
#include "override.hpp"
#ifdef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
#error "Forcing error even when public functions not checked"
#endif

13
libs/contract/test/public_function/override_permissive.cpp Normal file
View File

@@ -0,0 +1,13 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test no error if permissive even when override f does not actually override.
#ifndef BOOST_CONTRACT_PERMISSIVE
#error "build must define PERMISSIVE"
#endif
#include "override.hpp"

88
libs/contract/test/public_function/protected.cpp Normal file
View File

@@ -0,0 +1,88 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test overriding function never overrides protected function contract.
#include "../detail/oteststream.hpp"
#include <boost/contract/function.hpp>
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct b {
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
protected:
// NOTE: This is the correct way of programming contracts for overridden
// protected and overriding public functions: Both must use virtual_
// (otherwise C++ won't override because mismatching parameters), but
// overridden protected does not use public_function.
virtual void f(boost::contract::virtual_* /* v */ = 0) {
boost::contract::check c = boost::contract::function()
.precondition([] { out << "b::f::pre" << std::endl; })
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
;
out << "b::f::body" << std::endl;
}
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
void f(boost::contract::virtual_* v = 0) /* not override */ {
// C++ func a::f overrides b::f, but contracts don't (so no override_f).
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f();
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

52
libs/contract/test/public_function/protected_error.cpp Normal file
View File

@@ -0,0 +1,52 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test a public function contract cannot override from a protected one.
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
struct b {
protected:
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this);
}
friend class boost::contract::access; // Test this cannot prevent error.
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this); // Error (override cannot access b::f).
#ifdef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
#error "Forcing error even when public functions not checked"
#endif
}
// Correctly, GCC and CLang cannot even see b::f as part of overloaded bases
// because it is protected. MSVC also fails compilation but only when
// override_f below tries to call b::f (because it is protected so it cannot
// be seen from within override_f).
BOOST_CONTRACT_OVERRIDE(f)
friend class boost::contract::access; // Test this cannot prevent error.
};
int main() {
a aa;
aa.f();
return 0;
}

104
libs/contract/test/public_function/smoke.cpp Normal file
View File

@@ -0,0 +1,104 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public member function subcontracting.
#include "smoke.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
a aa; // Test call to derived out-most leaf.
s_type s; s.value = "A";
out.str("");
result_type& r = aa.f(s);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
<< "e::f::pre" << std::endl
<< "c::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "d::f::old" << std::endl
<< "d::f::post" << std::endl
<< "e::f::old" << std::endl
<< "e::f::post" << std::endl
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST_EQ(r.value, "A");
BOOST_TEST_EQ(s.value, "acde");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 for local var.
BOOST_TEST_EQ(aa.x.value, "aA");
BOOST_TEST_EQ(aa.x.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.ctors(), aa.x.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(aa.y.value, "cA");
BOOST_TEST_EQ(aa.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.y.ctors(), aa.y.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(aa.t<'d'>::z.value, "dA");
BOOST_TEST_EQ(aa.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'d'>::z.ctors(), aa.t<'d'>::z.dtors() + 1); // 1 member.
BOOST_TEST_EQ(aa.t<'e'>::z.value, "eA");
BOOST_TEST_EQ(aa.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'e'>::z.ctors(), aa.t<'e'>::z.dtors() + 1); // 1 member.
#undef BOOST_CONTRACT_TEST_old
return boost::report_errors();
}

278
libs/contract/test/public_function/smoke.hpp Normal file
View File

@@ -0,0 +1,278 @@
#ifndef BOOST_CONTRACT_TEST_PUBLIC_FUNCTION_CONTRACTS_HPP_
#define BOOST_CONTRACT_TEST_PUBLIC_FUNCTION_CONTRACTS_HPP_
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public member function subcontracting (also with old and return values).
#include "../detail/oteststream.hpp"
#include "../detail/counter.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/old.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/override.hpp>
#include <boost/config.hpp>
#include <string>
boost::contract::test::detail::oteststream out;
struct s_tag;
typedef boost::contract::test::detail::counter<s_tag, std::string> s_type;
struct except_error {};
struct result_type {
std::string value;
explicit result_type(std::string const& s) : value(s) {}
private: // Test non-copyable and non-default-constructible result.
result_type();
result_type(result_type const&);
result_type& operator=(result_type const&);
};
// Test base without additional bases and pure virtual.
template<char Id>
struct t {
static void static_invariant() { out << Id << "::static_inv" << std::endl; }
void invariant() const {
out << Id << "::inv" << std::endl;
BOOST_CONTRACT_ASSERT(z.value != "");
}
struct z_tag;
typedef boost::contract::test::detail::counter<z_tag, std::string> z_type;
z_type z;
t() { z.value.push_back(Id); }
virtual result_type& f(s_type& s, boost::contract::virtual_* v = 0) = 0;
};
template<char Id> // Requires: Only pass lower case Id so it'll never be 'X'.
result_type& t<Id>::f(s_type& s, boost::contract::virtual_* v) {
std::ostringstream r; r << "none-" << Id;
static result_type result(r.str());
boost::contract::old_ptr<z_type> old_z =
BOOST_CONTRACT_OLDOF(v, z_type::eval(z));
boost::contract::old_ptr<s_type> old_s;
boost::contract::check c = boost::contract::public_function(v, result, this)
.precondition([&] {
out << Id << "::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s.value[0] == Id || s.value[0] == 'X');
})
.old([&] {
out << Id << "::f::old" << std::endl;
old_s = BOOST_CONTRACT_OLDOF(v, s_type::eval(s));
})
.postcondition([&] (result_type const& result) {
out << Id << "::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(z.value == old_z->value + old_s->value);
BOOST_CONTRACT_ASSERT(s.value.find(old_z->value) !=
std::string::npos);
BOOST_CONTRACT_ASSERT(result.value == old_s->value);
})
.except([&] {
out << Id << "::f::except" << std::endl;
BOOST_CONTRACT_ASSERT(z.value == old_z->value);
BOOST_CONTRACT_ASSERT(s.value == old_s->value);
})
;
out << "t<" << Id << ">::f::body" << std::endl;
if(s.value == "X") throw except_error();
return result;
}
// Test base with other bases, multiple inheritance, and no subcontracting from
// protected and private bases (even if fully contracted).
struct c
#define BASES public t<'d'>, protected t<'p'>, private t<'q'>, public t<'e'>
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "c::static_inv" << std::endl; }
void invariant() const {
out << "c::inv" << std::endl;
BOOST_CONTRACT_ASSERT(y.value != "");
}
struct y_tag;
typedef boost::contract::test::detail::counter<y_tag, std::string> y_type;
y_type y;
c() { y.value = "c"; }
virtual result_type& f(s_type& s, boost::contract::virtual_* v = 0)
/* override */ {
static result_type result("none-c");
boost::contract::old_ptr<y_type> old_y =
BOOST_CONTRACT_OLDOF(v, y_type::eval(y));
boost::contract::old_ptr<s_type> old_s;
boost::contract::check c = boost::contract::public_function<
override_f>(v, result, &c::f, this, s)
.precondition([&] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s.value == "C" || s.value == "X");
})
.old([&] {
out << "c::f::old" << std::endl;
old_s = BOOST_CONTRACT_OLDOF(v, s_type::eval(s));
})
.postcondition([&] (result_type const& result) {
out << "c::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(y.value == old_y->value + old_s->value);
BOOST_CONTRACT_ASSERT(s.value.find(old_y->value) !=
std::string::npos);
BOOST_CONTRACT_ASSERT(result.value == old_s->value);
})
.except([&] {
out << "c::f::except" << std::endl;
BOOST_CONTRACT_ASSERT(y.value == old_y->value);
BOOST_CONTRACT_ASSERT(s.value == old_s->value);
})
;
out << "c::f::body" << std::endl;
if(s.value == "X") throw except_error();
std::string save_s = s.value;
std::string save = y.value;
y.value += save_s;
s.value = save;
save = t<'d'>::z.value;
t<'d'>::z.value += save_s;
s.value += save;
save = t<'e'>::z.value;
t<'e'>::z.value += save_s;
s.value += save;
result.value = save_s;
return result;
}
BOOST_CONTRACT_OVERRIDE(f)
};
// Test no subcontracting from not (fully) contracted base.
struct b {
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual ~b() {}
// No contract (no virtual_ so this is not actually overridden by a::f).
virtual result_type& f(s_type& s) {
static result_type result("none-b");
out << "b::f::body" << std::endl;
result.value = s.value;
return result;
}
};
// Test public function with both non-contracted and contracted bases.
struct a
#define BASES public b, public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const {
out << "a::inv" << std::endl;
BOOST_CONTRACT_ASSERT(x.value != "");
}
struct x_tag;
typedef boost::contract::test::detail::counter<x_tag, std::string> x_type;
x_type x;
a() { x.value = "a"; }
#if defined(BOOST_GCC)
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Woverloaded-virtual" // For a::f.
#elif defined(BOOST_CLANG)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Woverloaded-virtual" // For a::f.
#endif
// Must use virtual_ even if no longer decl virtual for correct overloading.
// NOTE: This intentionally hides but does not override `b::f` (it overrides
// `c::f` instead). This generates warnings on some compilers (Clang, etc.).
result_type& f(s_type& s, boost::contract::virtual_* v = 0)
/* override */ {
static result_type result("none-a");
boost::contract::old_ptr<x_type> old_x =
BOOST_CONTRACT_OLDOF(v, x_type::eval(x));
boost::contract::old_ptr<s_type> old_s;
boost::contract::check c = boost::contract::public_function<
override_f>(v, result, &a::f, this, s)
.precondition([&] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(s.value == "A" || s.value == "X");
})
.old([&] {
out << "a::f::old" << std::endl;
old_s = BOOST_CONTRACT_OLDOF(v, s_type::eval(s));
})
.postcondition([&] (result_type const& result) {
out << "a::f::post" << std::endl;
BOOST_CONTRACT_ASSERT(x.value == old_x->value + old_s->value);
BOOST_CONTRACT_ASSERT(s.value.find(old_x->value) !=
std::string::npos);
BOOST_CONTRACT_ASSERT(result.value == old_s->value);
})
.except([&] {
out << "a::f::except" << std::endl;
BOOST_CONTRACT_ASSERT(x.value == old_x->value);
BOOST_CONTRACT_ASSERT(s.value == old_s->value);
})
;
out << "a::f::body" << std::endl;
if(s.value == "X") throw except_error();
std::string save_s = s.value;
std::string save = x.value;
x.value += save_s;
s.value = save;
save = y.value;
y.value += save_s;
s.value += save;
save = t<'d'>::z.value;
t<'d'>::z.value += save_s;
s.value += save;
save = t<'e'>::z.value;
t<'e'>::z.value += save_s;
s.value += save;
result.value = save_s;
return result;
}
BOOST_CONTRACT_OVERRIDE(f)
#if defined(BOOST_GCC)
#pragma GCC diagnostic pop
#elif defined(BOOST_CLANG)
#pragma clang diagnostic pop
#endif
};
#endif // #include guard

82
libs/contract/test/public_function/static.cpp Normal file
View File

@@ -0,0 +1,82 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public static member function contracts.
#include "../detail/oteststream.hpp"
#include <boost/contract/base_types.hpp>
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct b {
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<b>()
.precondition([] { out << "b::f::pre" << std::endl; })
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
;
out << "b::f::body" << std::endl;
}
};
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<a>()
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
out.str("");
a::f();
ok.str(""); ok
// Static so no object thus only static inv, plus never virtual so subst
// principle does not apply and no subcontracting.
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

74
libs/contract/test/public_function/static_ifdef.cpp Normal file
View File

@@ -0,0 +1,74 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public static member function contract compilation on/off.
#include "../detail/oteststream.hpp"
#include <boost/contract/core/config.hpp>
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/old.hpp>
#endif
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a {
#ifndef BOOST_CONTRACT_NO_INVARIANTS
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
#endif
static void f(int x) {
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
boost::contract::old_ptr<int> old_x = BOOST_CONTRACT_OLDOF(x);
#endif
#ifndef BOOST_CONTRACT_NO_PUBLIC_FUNCTIONS
boost::contract::check c = boost::contract::public_function<a>()
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
.precondition([] { out << "a::f::pre" << std::endl; })
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
#endif
;
#endif
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
out.str("");
a::f(123);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
// Test no post (but still static inv) because body threw.
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

90
libs/contract/test/public_function/static_ifdef_macro.cpp Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public static member function contract compilation on/off (w/ macros).
#include "../detail/oteststream.hpp"
#include "../detail/unprotected_commas.hpp"
#include <boost/contract/core/config.hpp>
#include <boost/contract_macro.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a {
BOOST_CONTRACT_STATIC_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "a::static_inv" << std::endl;
})
BOOST_CONTRACT_INVARIANT({
boost::contract::test::detail::unprotected_commas<void, void, void>::
call();
out << "a::inv" << std::endl;
})
static void f(int x) {
BOOST_CONTRACT_OLD_PTR(
boost::contract::test::detail::unprotected_commas<int, void, void>::
type1
)(
old_x,
(boost::contract::test::detail::unprotected_commas<void, void,
void>::same(x))
);
BOOST_CONTRACT_STATIC_PUBLIC_FUNCTION(boost::contract::test::detail::
unprotected_commas<a, void, void>::type1)
BOOST_CONTRACT_PRECONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::pre" << std::endl;
})
BOOST_CONTRACT_OLD([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::old" << std::endl;
})
BOOST_CONTRACT_POSTCONDITION([] {
boost::contract::test::detail::unprotected_commas<
void, void, void>::call();
out << "a::f::post" << std::endl;
})
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
out.str("");
a::f(123);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
// Test no post (but still static inv) because body threw.
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

67
libs/contract/test/public_function/static_throwing_body.cpp Normal file
View File

@@ -0,0 +1,67 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public static member function throwing.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a {
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<a>()
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
throw a_err(); // Test this throws.
}
};
int main() {
std::ostringstream ok;
try {
out.str("");
a::f();
BOOST_TEST(false);
} catch(a_err const&) {
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl // Test this threw.
// Test no post (but still static inv) because body threw.
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_EXCEPTS
<< "a::f::except" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

71
libs/contract/test/public_function/static_throwing_old.cpp Normal file
View File

@@ -0,0 +1,71 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public static member function .old().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a {
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<a>()
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] {
out << "a::f::old" << std::endl;
throw a_err(); // Test this throws.
})
.postcondition([] { out << "a::f::post" << std::endl; })
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
boost::contract::set_old_failure([] (boost::contract::from) { throw; });
try {
out.str("");
a::f();
#ifndef BOOST_CONTRACT_NO_OLDS
BOOST_TEST(false);
} catch(a_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl // Test this threw.
#else
<< "a::f::body" << std::endl
// Test no post (but still static inv) because .old() threw.
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

73
libs/contract/test/public_function/static_throwing_post.cpp Normal file
View File

@@ -0,0 +1,73 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public static member function .post().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a {
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<a>()
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] {
out << "a::f::post" << std::endl;
throw a_err(); // Test this throws.
})
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
boost::contract::set_postcondition_failure(
[] (boost::contract::from) { throw; });
try {
out.str("");
a::f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(a_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::post" << std::endl // Test this threw.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

74
libs/contract/test/public_function/static_throwing_pre.cpp Normal file
View File

@@ -0,0 +1,74 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public static member function .pre().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a {
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
static void f() {
boost::contract::check c = boost::contract::public_function<a>()
.precondition([] {
out << "a::f::pre" << std::endl;
throw a_err(); // Test this throws.
})
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
boost::contract::set_precondition_failure(
[] (boost::contract::from) { throw; });
try {
out.str("");
a::f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(a_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::f::pre" << std::endl // Test this threw.
#else
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::static_inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::f::post" << std::endl
#endif
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

106
libs/contract/test/public_function/throwing_body.cpp Normal file
View File

@@ -0,0 +1,106 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public member function body throws with subcontracting.
#include "smoke.hpp"
#include <boost/optional.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
a aa; // Test call to derived out-most leaf.
s_type s; s.value = "X"; // So body will throw.
out.str("");
boost::optional<result_type&> r;
try {
r = aa.f(s);
BOOST_TEST(false);
} catch(except_error const&) {
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_EXCEPTS
<< "d::f::old" << std::endl
<< "d::f::except" << std::endl
<< "e::f::old" << std::endl
<< "e::f::except" << std::endl
<< "c::f::old" << std::endl
<< "c::f::except" << std::endl
// No old call here because not a base object.
<< "a::f::except" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST(!r); // Boost.Optional result not init (as body threw).
BOOST_TEST_EQ(s.value, "X");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 for local var.
BOOST_TEST_EQ(aa.x.value, "a");
BOOST_TEST_EQ(aa.x.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.ctors(), aa.x.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(aa.y.value, "c");
BOOST_TEST_EQ(aa.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.y.ctors(), aa.y.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(aa.t<'d'>::z.value, "d");
BOOST_TEST_EQ(aa.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'d'>::z.ctors(), aa.t<'d'>::z.dtors() + 1); // 1 mem.
BOOST_TEST_EQ(aa.t<'e'>::z.value, "e");
BOOST_TEST_EQ(aa.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.t<'e'>::z.ctors(), aa.t<'e'>::z.dtors() + 1); // 1 mem.
#undef BOOST_CONTRACT_TEST_old
}
return boost::report_errors();
}

108
libs/contract/test/public_function/throwing_body_virtual.cpp Normal file
View File

@@ -0,0 +1,108 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test virtual public member function body throws with subcontracting.
#include "smoke.hpp"
#include <boost/optional.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
a aa; // Test call to derived out-most leaf.
c& ca = aa; // Test polymorphic virtual call (via reference to base c).
s_type s; s.value = "X"; // So body will throw.
out.str("");
boost::optional<result_type&> r;
try {
r = ca.f(s);
BOOST_TEST(false);
} catch(except_error const&) {
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_EXCEPTS
<< "d::f::old" << std::endl
<< "d::f::except" << std::endl
<< "e::f::old" << std::endl
<< "e::f::except" << std::endl
<< "c::f::old" << std::endl
<< "c::f::except" << std::endl
// No old call here because not a base object.
<< "a::f::except" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST(!r); // Boost.Optional result not init (as body threw).
BOOST_TEST_EQ(s.value, "X");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 for local var.
// Cannot access x via ca, but only via aa.
BOOST_TEST_EQ(aa.x.value, "a");
BOOST_TEST_EQ(aa.x.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.ctors(), aa.x.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(ca.y.value, "c");
BOOST_TEST_EQ(ca.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.y.ctors(), aa.y.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(ca.t<'d'>::z.value, "d");
BOOST_TEST_EQ(ca.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'d'>::z.ctors(), aa.t<'d'>::z.dtors() + 1); // 1 mem.
BOOST_TEST_EQ(ca.t<'e'>::z.value, "e");
BOOST_TEST_EQ(ca.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'e'>::z.ctors(), aa.t<'e'>::z.dtors() + 1); // 1 mem.
#undef BOOST_CONTRACT_TEST_old
}
return boost::report_errors();
}

94
libs/contract/test/public_function/throwing_body_virtual_branch.cpp Normal file
View File

@@ -0,0 +1,94 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test virt pub func body throws with subcontr from middle of inheritance tree.
#include "smoke.hpp"
#include <boost/optional.hpp>
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
c cc; // Test call to class at mid- inheritance tree (as base with bases).
s_type s; s.value = "X"; // So body will throw.
out.str("");
boost::optional<result_type&> r;
try {
r = cc.f(s);
BOOST_TEST(false);
} catch(except_error const&) {
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
#endif
<< "c::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_EXCEPTS
<< "d::f::old" << std::endl
<< "d::f::except" << std::endl
<< "e::f::old" << std::endl
<< "e::f::except" << std::endl
// No old call here because not a base object.
<< "c::f::except" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST(!r); // Boost.Optional result not init (as body threw).
BOOST_TEST_EQ(s.value, "X");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 3);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 3);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 for local var.
BOOST_TEST_EQ(cc.y.value, "c");
BOOST_TEST_EQ(cc.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.y.ctors(), cc.y.dtors() + 1); // 1 for member var.
BOOST_TEST_EQ(cc.t<'d'>::z.value, "d");
BOOST_TEST_EQ(cc.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'d'>::z.ctors(), cc.t<'d'>::z.dtors() + 1); // 1 mem.
BOOST_TEST_EQ(cc.t<'e'>::z.value, "e");
BOOST_TEST_EQ(cc.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'e'>::z.ctors(), cc.t<'e'>::z.dtors() + 1); // 1 mem.
#undef BOOST_CONTRACT_TEST_old
}
return boost::report_errors();
}

149
libs/contract/test/public_function/throwing_old.cpp Normal file
View File

@@ -0,0 +1,149 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public function (derived and bases) .old().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct c_err {}; // Global decl so visible in MSVC10 lambdas.
struct c {
static void static_invariant() { out << "c::static_inv" << std::endl; }
void invariant() const { out << "c::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] {
out << "c::f::old" << std::endl;
throw c_err(); // Test this throws.
})
.postcondition([] { out << "c::f::post" << std::endl; })
.except([] { out << "c::f::except" << std::endl; })
;
out << "c::f::body" << std::endl;
}
};
struct b_err {}; // Global decl so visible in MSVC10 lambdas.
struct b
#define BASES public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &b::f, this)
.precondition([] {
out << "b::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] {
out << "b::f::old" << std::endl;
throw b_err(); // Test this throws.
})
.postcondition([] { out << "b::f::post" << std::endl; })
.except([] { out << "b::f::except" << std::endl; })
;
out << "b::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] {
out << "a::f::old" << std::endl;
throw a_err(); // Test this throws.
})
.postcondition([] { out << "a::f::post" << std::endl; })
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
std::ostringstream ok;
boost::contract::set_old_failure([] (boost::contract::from) { throw; });
a aa;
b& ba = aa; // Test as virtual call via polymorphism.
try {
out.str("");
ba.f();
#ifndef BOOST_CONTRACT_NO_OLDS
BOOST_TEST(false);
} catch(c_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl // Test this threw.
#else
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

157
libs/contract/test/public_function/throwing_post.cpp Normal file
View File

@@ -0,0 +1,157 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public function (derived and bases) .post().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct c_err {}; // Global decl so visible in MSVC10 lambdas.
struct c {
static void static_invariant() { out << "c::static_inv" << std::endl; }
void invariant() const { out << "c::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] { out << "c::f::old" << std::endl; })
.postcondition([] {
out << "c::f::post" << std::endl;
// Test derived will throw.
})
.except([] { out << "c::f::except" << std::endl; })
;
out << "c::f::body" << std::endl;
}
};
struct b_err {}; // Global decl so visible in MSVC10 lambdas.
struct b
#define BASES public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &b::f, this)
.precondition([] {
out << "b::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] {
out << "b::f::post" << std::endl;
throw b_err(); // Test this (both derived and base) throws.
})
.except([] { out << "b::f::except" << std::endl; })
;
out << "b::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] {
out << "a::f::post" << std::endl;
throw a_err(); // Test base already threw.
})
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
std::ostringstream ok;
boost::contract::set_postcondition_failure(
[] (boost::contract::from) { throw; });
a aa;
b& ba = aa; // Test as virtual call via polymorphism.
try {
out.str("");
ba.f();
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
BOOST_TEST(false);
} catch(b_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl // Test this threw.
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

154
libs/contract/test/public_function/throwing_pre.cpp Normal file
View File

@@ -0,0 +1,154 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test throw from public function (derived and bases) .pre().
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct c_err {}; // Global decl so visible in MSVC10 lambdas.
struct c {
static void static_invariant() { out << "c::static_inv" << std::endl; }
void invariant() const { out << "c::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] { out << "c::f::old" << std::endl; })
.postcondition([] { out << "c::f::post" << std::endl; })
.except([] { out << "c::f::except" << std::endl; })
;
out << "c::f::body" << std::endl;
}
};
struct b_err {}; // Global decl so visible in MSVC10 lambdas.
struct b
#define BASES public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &b::f, this)
.precondition([] {
out << "b::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(false); // To check derived pre.
})
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
.except([] { out << "b::f::except" << std::endl; })
;
out << "b::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct a_err {}; // Global decl so visible in MSVC10 lambdas.
struct a
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
.precondition([] {
out << "a::f::pre" << std::endl;
throw a_err(); // Test this throws.
})
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
.except([] { out << "a::f::except" << std::endl; })
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
std::ostringstream ok;
boost::contract::set_precondition_failure(
[] (boost::contract::from) { throw; });
a aa;
b& ba = aa; // Test as virtual call via polymorphism.
try {
out.str("");
ba.f();
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
BOOST_TEST(false);
} catch(a_err const&) {
#endif
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "b::f::pre" << std::endl
<< "a::f::pre" << std::endl // Test this threw.
#else
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "b::static_inv" << std::endl
<< "b::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
#endif
;
BOOST_TEST(out.eq(ok.str()));
} catch(...) { BOOST_TEST(false); }
return boost::report_errors();
}

106
libs/contract/test/public_function/virtual.cpp Normal file
View File

@@ -0,0 +1,106 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public function subcontracting via virtual functions.
#include "smoke.hpp"
#include <boost/preprocessor/control/iif.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
a aa;
c& ca = aa; // Test polymorphic virtual call (via reference to base c).
s_type s; s.value = "A";
out.str("");
result_type& r = ca.f(s);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
<< "e::f::pre" << std::endl
<< "c::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "d::f::old" << std::endl
<< "d::f::post" << std::endl
<< "e::f::old" << std::endl
<< "e::f::post" << std::endl
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST_EQ(r.value, "A");
BOOST_TEST_EQ(s.value, "acde");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 4);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 local var.
// Cannot access x via ca, but only via aa.
BOOST_TEST_EQ(aa.x.value, "aA");
BOOST_TEST_EQ(aa.x.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(aa.x.ctors(), aa.x.dtors() + 1); // 1 data member.
BOOST_TEST_EQ(ca.y.value, "cA");
BOOST_TEST_EQ(ca.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.y.ctors(), ca.y.dtors() + 1); // 1 data member.
BOOST_TEST_EQ(ca.t<'d'>::z.value, "dA");
BOOST_TEST_EQ(ca.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'d'>::z.ctors(), ca.t<'d'>::z.dtors() + 1); // 1 member.
BOOST_TEST_EQ(ca.t<'e'>::z.value, "eA");
BOOST_TEST_EQ(ca.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(ca.t<'e'>::z.ctors(), ca.t<'e'>::z.dtors() + 1); // 1 member.
#undef BOOST_CONTRACT_TEST_old
return boost::report_errors();
}

220
libs/contract/test/public_function/virtual_access.cpp Normal file
View File

@@ -0,0 +1,220 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test overrides with mixed access level from (single) base.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct b { // Test all access levels (public, protected, and private).
friend void call(b& me) { // Test polymorphic calls (object by &).
me.f();
me.g();
me.h();
}
static void statci_inv() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f::pre" << std::endl; })
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
;
out << "b::f::body" << std::endl;
}
// NOTE: Both protected and private virtual members must declare
// extra `virtual_* = 0` parameter (otherwise they cannot be overridden in
// derived classes with contracts because C++ uses also default parameters
// to match signature of overriding functions).
protected:
virtual void g(boost::contract::virtual_* /* v */= 0) {
boost::contract::check c = boost::contract::function()
.precondition([] { out << "b::g::pre" << std::endl; })
.old([] { out << "b::g::old" << std::endl; })
.postcondition([] { out << "b::g::post" << std::endl; })
;
out << "b::g::body" << std::endl;
}
private:
virtual void h(boost::contract::virtual_* /* v */ = 0) {
boost::contract::check c = boost::contract::function()
.precondition([] { out << "b::h::pre" << std::endl; })
.old([] { out << "b::h::old" << std::endl; })
.postcondition([] { out << "b::h::post" << std::endl; })
;
out << "b::h::body" << std::endl;
}
};
struct a // Test overrides with mixed access levels from base.
#define BASES public b
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void statci_inv() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDES(f)
// Following do not override public members so no `override_...` param and
// they do not actually subcontract.
virtual void g(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "a::g::pre" << std::endl; })
.old([] { out << "a::g::old" << std::endl; })
.postcondition([] { out << "a::g::post" << std::endl; })
;
out << "a::g::body" << std::endl;
}
virtual void h(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "a::h::pre" << std::endl; })
.old([] { out << "a::h::old" << std::endl; })
.postcondition([] { out << "a::h::post" << std::endl; })
;
out << "a::h::body" << std::endl;
}
};
int main() {
std::ostringstream ok;
b bb;
out.str("");
call(bb);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
#endif
<< "b::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::g::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::g::old" << std::endl
#endif
<< "b::g::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::g::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::h::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::h::old" << std::endl
#endif
<< "b::h::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::h::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
a aa;
out.str("");
call(aa);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::g::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::g::old" << std::endl
#endif
<< "a::g::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::g::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "a::h::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "a::h::old" << std::endl
#endif
<< "a::h::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "a::h::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}

283
libs/contract/test/public_function/virtual_access_multi.cpp Normal file
View File

@@ -0,0 +1,283 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test overrides with mixed access levels from different (multiple) bases.
#include <boost/config.hpp>
#ifdef BOOST_MSVC
// WARNING: MSVC (at least up to VS 2015) gives a compile-time error if SFINAE
// cannot introspect a member because of its private or protected access level.
// That is incorrect, SFINAE should fail in these cases without generating
// compile-time errors like GCC and CLang do. Therefore, currently it is not
// possible to override a member that is public in one base but private or
// protected in other base using this library on MSVC (that can be done instead
// using this library on GCC or CLang).
int main() { return 0; } // This test trivially passes on MSVC.
#else
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/function.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/check.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct c { // Test public access different from base `b`'s access below.
static void statci_inv() { out << "c::static_inv" << std::endl; }
void invariant() const { out << "c::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "c::f::pre" << std::endl; })
.old([] { out << "c::f::old" << std::endl; })
.postcondition([] { out << "c::f::post" << std::endl; })
;
out << "c::f::body" << std::endl;
}
virtual void g(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "c::g::pre" << std::endl; })
.old([] { out << "c::g::old" << std::endl; })
.postcondition([] { out << "c::g::post" << std::endl; })
;
out << "c::g::body" << std::endl;
}
virtual void h(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "c::h::pre" << std::endl; })
.old([] { out << "c::h::old" << std::endl; })
.postcondition([] { out << "c::h::post" << std::endl; })
;
out << "c::h::body" << std::endl;
}
};
struct b { // Test all access levels (public, protected, and private).
friend void call(b& me) { // Test polymorphic calls (object by &).
me.f();
me.g();
me.h();
}
static void statci_inv() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([] { out << "b::f::pre" << std::endl; })
.old([] { out << "b::f::old" << std::endl; })
.postcondition([] { out << "b::f::post" << std::endl; })
;
out << "b::f::body" << std::endl;
}
// NOTE: Both protected and private virtual members must declare
// extra `virtual_* = 0` parameter (otherwise they cannot be overridden in
// derived classes with contracts because C++ uses also default parameters
// to match signature of overriding functions).
protected:
virtual void g(boost::contract::virtual_* /* v */ = 0) {
boost::contract::check c = boost::contract::function()
.precondition([] { out << "b::g::pre" << std::endl; })
.old([] { out << "b::g::old" << std::endl; })
.postcondition([] { out << "b::g::post" << std::endl; })
;
out << "b::g::body" << std::endl;
}
private:
virtual void h(boost::contract::virtual_* /* v */ = 0) {
boost::contract::check c = boost::contract::function()
.precondition([] { out << "b::h::pre" << std::endl; })
.old([] { out << "b::h::old" << std::endl; })
.postcondition([] { out << "b::h::post" << std::endl; })
;
out << "b::h::body" << std::endl;
}
};
struct a // Test overrides with mixed access levels from different bases.
#define BASES public b, public c
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void statci_inv() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
virtual void f(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_f>(
v, &a::f, this)
.precondition([] { out << "a::f::pre" << std::endl; })
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
virtual void g(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_g>(
v, &a::g, this)
.precondition([] { out << "a::g::pre" << std::endl; })
.old([] { out << "a::g::old" << std::endl; })
.postcondition([] { out << "a::g::post" << std::endl; })
;
out << "a::g::body" << std::endl;
}
virtual void h(boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<override_h>(
v, &a::h, this)
.precondition([] { out << "a::h::pre" << std::endl; })
.old([] { out << "a::h::old" << std::endl; })
.postcondition([] { out << "a::h::post" << std::endl; })
;
out << "a::h::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDES(f, g, h)
};
int main() {
std::ostringstream ok;
b bb;
out.str("");
call(bb);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
#endif
<< "b::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::g::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::g::old" << std::endl
#endif
<< "b::g::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::g::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::h::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::h::old" << std::endl
#endif
<< "b::h::body" << std::endl
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::h::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
a aa;
out.str("");
call(aa);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "b::inv" << std::endl
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "b::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "b::f::old" << std::endl
<< "c::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "b::inv" << std::endl
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "b::f::old" << std::endl
<< "b::f::post" << std::endl
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "a::f::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::g::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::g::old" << std::endl
<< "a::g::old" << std::endl
#endif
<< "a::g::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::g::old" << std::endl
<< "c::g::post" << std::endl
<< "a::g::post" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::h::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::h::old" << std::endl
<< "a::h::old" << std::endl
#endif
<< "a::h::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::h::old" << std::endl
<< "c::h::post" << std::endl
<< "a::h::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}
#endif // MSVC

90
libs/contract/test/public_function/virtual_branch.cpp Normal file
View File

@@ -0,0 +1,90 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test public function subcontracting from middle branch of inheritance tree.
#include "smoke.hpp"
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
int main() {
std::ostringstream ok;
c cc; // Test call to class at mid- inheritance tree (a base with bases).
s_type s; s.value = "C";
out.str("");
result_type& r = cc.f(s);
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "d::f::pre" << std::endl
<< "e::f::pre" << std::endl
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "d::f::old" << std::endl
<< "e::f::old" << std::endl
<< "c::f::old" << std::endl
#endif
<< "c::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "d::static_inv" << std::endl
<< "d::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "d::f::old" << std::endl
<< "d::f::post" << std::endl
<< "e::f::old" << std::endl
<< "e::f::post" << std::endl
// No old call here because not a base object.
<< "c::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
#ifndef BOOST_CONTRACT_NO_OLDS
#define BOOST_CONTRACT_TEST_old 1u
#else
#define BOOST_CONTRACT_TEST_old 0u
#endif
BOOST_TEST_EQ(r.value, "C");
BOOST_TEST_EQ(s.value, "cde");
BOOST_TEST_EQ(s.copies(), BOOST_CONTRACT_TEST_old * 3);
BOOST_TEST_EQ(s.evals(), BOOST_CONTRACT_TEST_old * 3);
BOOST_TEST_EQ(s.ctors(), s.dtors() + 1); // 1 local var.
BOOST_TEST_EQ(cc.y.value, "cC");
BOOST_TEST_EQ(cc.y.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.y.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.y.ctors(), cc.y.dtors() + 1); // 1 data member.
BOOST_TEST_EQ(cc.t<'d'>::z.value, "dC");
BOOST_TEST_EQ(cc.t<'d'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'d'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'d'>::z.ctors(), cc.t<'d'>::z.dtors() + 1); // 1 member.
BOOST_TEST_EQ(cc.t<'e'>::z.value, "eC");
BOOST_TEST_EQ(cc.t<'e'>::z.copies(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'e'>::z.evals(), BOOST_CONTRACT_TEST_old);
BOOST_TEST_EQ(cc.t<'e'>::z.ctors(), cc.t<'e'>::z.dtors() + 1); // 1 member.
#undef BOOST_CONTRACT_TEST_old
return boost::report_errors();
}

418
libs/contract/test/public_function/virtual_sparse.cpp Normal file
View File

@@ -0,0 +1,418 @@
// Copyright (C) 2008-2018 Lorenzo Caminiti
// Distributed under the Boost Software License, Version 1.0 (see accompanying
// file LICENSE_1_0.txt or a copy at http://www.boost.org/LICENSE_1_0.txt).
// See: http://www.boost.org/doc/libs/release/libs/contract/doc/html/index.html
// Test subcontracting with sparse and complex inheritance graph.
#include "../detail/oteststream.hpp"
#include <boost/contract/public_function.hpp>
#include <boost/contract/assert.hpp>
#include <boost/contract/check.hpp>
#include <boost/contract/override.hpp>
#include <boost/contract/base_types.hpp>
#include <boost/detail/lightweight_test.hpp>
#include <sstream>
boost::contract::test::detail::oteststream out;
struct j {
static void static_invariant() { out << "j::static_inv" << std::endl; }
void invariant() const { out << "j::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([&] {
out << "j::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'j');
})
.old([] { out << "j::f::old" << std::endl; })
.postcondition([] { out << "j::f::post" << std::endl; })
;
out << "j::f::body" << std::endl;
}
};
struct i {
static void static_invariant() { out << "i::static_inv" << std::endl; }
void invariant() const { out << "i::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([&] {
out << "i::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'i');
})
.old([] { out << "i::f::old" << std::endl; })
.postcondition([] { out << "i::f::post" << std::endl; })
;
out << "i::f::body" << std::endl;
}
};
struct k {};
struct h
#define BASES public j
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "h::static_inv" << std::endl; }
void invariant() const { out << "h::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<
override_f>(v, &h::f, this, ch)
.precondition([&] {
out << "h::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'h');
})
.old([] { out << "h::f::old" << std::endl; })
.postcondition([] { out << "h::f::post" << std::endl; })
;
out << "h::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct e
#define BASES public virtual i
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "e::static_inv" << std::endl; }
void invariant() const { out << "e::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<
override_f>(v, &e::f, this, ch)
.precondition([&] {
out << "e::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'e');
})
.old([] { out << "e::f::old" << std::endl; })
.postcondition([] { out << "e::f::post" << std::endl; })
;
out << "e::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
struct d
#define BASES public k, virtual public i
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "d::static_inv" << std::endl; }
void invariant() const { out << "d::inv" << std::endl; }
};
struct c {
static void static_invariant() { out << "c::static_inv" << std::endl; }
void invariant() const { out << "c::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) {
boost::contract::check c = boost::contract::public_function(v, this)
.precondition([&] {
out << "c::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'c');
})
.old([] { out << "c::f::old" << std::endl; })
.postcondition([] { out << "c::f::post" << std::endl; })
;
out << "c::f::body" << std::endl;
}
};
struct b
#define BASES public c, public d
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "b::static_inv" << std::endl; }
void invariant() const { out << "b::inv" << std::endl; }
};
struct x {};
struct y {};
struct z {};
struct a
#define BASES public b, public x, public e, protected y, public h, \
private z
: BASES
{
typedef BOOST_CONTRACT_BASE_TYPES(BASES) base_types;
#undef BASES
static void static_invariant() { out << "a::static_inv" << std::endl; }
void invariant() const { out << "a::inv" << std::endl; }
virtual void f(char ch, boost::contract::virtual_* v = 0) /* override */ {
boost::contract::check c = boost::contract::public_function<
override_f>(v, &a::f, this, ch)
.precondition([&] {
out << "a::f::pre" << std::endl;
BOOST_CONTRACT_ASSERT(ch == 'a');
})
.old([] { out << "a::f::old" << std::endl; })
.postcondition([] { out << "a::f::post" << std::endl; })
;
out << "a::f::body" << std::endl;
}
BOOST_CONTRACT_OVERRIDE(f)
};
int main() {
std::ostringstream ok;
a aa;
out.str("");
aa.f('a');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
<< "h::static_inv" << std::endl
<< "h::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
<< "i::f::pre" << std::endl
<< "e::f::pre" << std::endl
<< "j::f::pre" << std::endl
<< "h::f::pre" << std::endl
<< "a::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
<< "i::f::old" << std::endl
<< "e::f::old" << std::endl
<< "j::f::old" << std::endl
<< "h::f::old" << std::endl
<< "a::f::old" << std::endl
#endif
<< "a::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
<< "h::static_inv" << std::endl
<< "h::inv" << std::endl
<< "a::static_inv" << std::endl
<< "a::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "c::f::old" << std::endl
<< "c::f::post" << std::endl
<< "i::f::old" << std::endl
<< "i::f::post" << std::endl
<< "e::f::old" << std::endl
<< "e::f::post" << std::endl
<< "j::f::old" << std::endl
<< "j::f::post" << std::endl
<< "h::f::old" << std::endl
<< "h::f::post" << std::endl
// No old call here because not a base object.
<< "a::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
c cc;
out.str("");
cc.f('c');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "c::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "c::f::old" << std::endl
#endif
<< "c::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "c::static_inv" << std::endl
<< "c::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not a base object.
<< "c::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
d dd;
out.str("");
dd.f('i'); // d's f inherited from i.
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "i::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "i::f::old" << std::endl
#endif
<< "i::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not a base object.
<< "i::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
e ee;
out.str("");
ee.f('e');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "i::f::pre" << std::endl
<< "e::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "i::f::old" << std::endl
<< "e::f::old" << std::endl
#endif
<< "e::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
<< "e::static_inv" << std::endl
<< "e::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "i::f::old" << std::endl
<< "i::f::post" << std::endl
// No old call here because not a base object.
<< "e::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
i ii;
out.str("");
ii.f('i');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "i::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "i::f::old" << std::endl
#endif
<< "i::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "i::static_inv" << std::endl
<< "i::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not a base object.
<< "i::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
h hh;
out.str("");
hh.f('h');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
<< "h::static_inv" << std::endl
<< "h::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "j::f::pre" << std::endl
<< "h::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "j::f::old" << std::endl
<< "h::f::old" << std::endl
#endif
<< "h::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
<< "h::static_inv" << std::endl
<< "h::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
<< "j::f::old" << std::endl
<< "j::f::post" << std::endl
// No old call here because not a base object.
<< "h::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
j jj;
out.str("");
jj.f('j');
ok.str(""); ok
#ifndef BOOST_CONTRACT_NO_ENTRY_INVARIANTS
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_PRECONDITIONS
<< "j::f::pre" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_OLDS
<< "j::f::old" << std::endl
#endif
<< "j::f::body" << std::endl
#ifndef BOOST_CONTRACT_NO_EXIT_INVARIANTS
<< "j::static_inv" << std::endl
<< "j::inv" << std::endl
#endif
#ifndef BOOST_CONTRACT_NO_POSTCONDITIONS
// No old call here because not a base object.
<< "j::f::post" << std::endl
#endif
;
BOOST_TEST(out.eq(ok.str()));
return boost::report_errors();
}