boost_mirror/json
1
0
Fork 0
mirror of https://github.com/boostorg/json.git synced 2025-05-11 05:33:57 +00:00
Code Issues Packages Projects Releases Wiki Activity

Add standalone test_suite

Browse Source
This commit is contained in:
Vinnie Falco 2019-12-11 08:31:10 -08:00
parent 3844c0eb09
commit 07246e2909
28 changed files with 2310 additions and 1640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
CMakeLists.txt
View File

@ -146,6 +146,7 @@ endif()
file (GLOB_RECURSE PROJECT_FILES
${PROJECT_SOURCE_DIR}/include/boost/json/*.hpp
${PROJECT_SOURCE_DIR}/include/boost/json/*.ipp
${PROJECT_SOURCE_DIR}/include/boost/json/*.natvis
)
add_subdirectory (bench)

2
bench/CMakeLists.txt
View File

@ -16,6 +16,8 @@ GroupSources(bench "/")
# Disable auto-linking
add_definitions(-DBOOST_ALL_NO_LIB=1)
include_directories(../test)
if (MSVC)
if (CMAKE_BUILD_TYPE EQUAL "Debug")
else()

4
bench/Jamfile
View File

@ -24,6 +24,8 @@ else
exe bench :
bench.cpp
: :
:
<include>../test
:
$(LIB)
;

7
bench/bench.cpp
View File

@ -19,7 +19,6 @@
#include "lib/rapidjson/include/rapidjson/stringbuffer.h"
#include <boost/json.hpp>
#include <boost/beast/_experimental/unit_test/dstream.hpp>
#include <algorithm>
#include <chrono>
#include <iostream>
@ -27,6 +26,8 @@
#include <cstdio>
#include <vector>
#include "test_suite.hpp"
/*
References
@ -37,14 +38,12 @@ http://seriot.ch/parsing_json.php
*/
namespace beast = boost::beast;
namespace boost {
namespace json {
using clock_type = std::chrono::steady_clock;
beast::unit_test::dstream dout(std::cerr);
::test_suite::debug_stream dout(std::cerr);
std::stringstream strout;
#if defined(BOOST_MSVC)

4
include/boost/json/detail/impl/array_impl.ipp
View File

@ -33,7 +33,7 @@ array_impl(
sizeof(table) + 1)
/ sizeof(table)
* sizeof(table),
std::max(
(std::max)(
alignof(table),
alignof(value)))) table;
tab_->capacity = static_cast<
@ -88,7 +88,7 @@ destroy_impl(
sizeof(table) + 1)
/ sizeof(table)
* sizeof(table),
std::max(
(std::max)(
alignof(table),
alignof(value)));
}

7
test/CMakeLists.txt
View File

@ -7,14 +7,16 @@
# Official repository: https://github.com/vinniefalco/json
#
source_group (json FILES ${PROJECT_SOURCE_DIR}/include/boost/json.hpp)
source_group (json FILES ${PROJECT_SOURCE_DIR}/include/boost/pilfer.hpp)
source_group (boost FILES ${PROJECT_SOURCE_DIR}/include/boost/json.hpp)
source_group (boost FILES ${PROJECT_SOURCE_DIR}/include/boost/pilfer.hpp)
source_group (TREE ${PROJECT_SOURCE_DIR}/include/boost/json PREFIX json FILES ${PROJECT_FILES})
GroupSources(test "/")
add_definitions(-DBOOST_JSON_HEADER_ONLY=1)
include_directories(.)
add_executable (json-tests
${BEAST_FILES}
${PROJECT_FILES}
@ -24,6 +26,7 @@ add_executable (json-tests
${PROJECT_SOURCE_DIR}/src/src.cpp
Jamfile
test.hpp
test_suite.hpp
parse-vectors.hpp
main.cpp
_detail_number.cpp

2
test/Jamfile
View File

@ -58,6 +58,7 @@ for local f in $(SOURCES)
RUN_TESTS += [
run $(f) main.cpp : : :
$(LIB)
<include>.
] ;
}
@ -66,6 +67,7 @@ for local f in $(LIMIT_SOURCES)
RUN_TESTS += [
run $(f) main.cpp : : :
<source>../src/src.cpp
<include>.
<define>BOOST_JSON_MAX_STRING_SIZE=1000
<define>BOOST_JSON_MAX_OBJECT_SIZE=30
<define>BOOST_JSON_MAX_ARRAY_SIZE=100

90
test/_detail_number.cpp
View File

@ -10,14 +10,15 @@
// Test that header file is self-contained.
#include <boost/json/detail/number.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <type_traits>
#include "test_suite.hpp"
namespace boost {
namespace json {
namespace detail {
class number_parser_test : public beast::unit_test::suite
class number_parser_test
{
public:
template<class F>
@ -30,9 +31,9 @@ public:
error_code ec;
number_parser p;
p.write(s.data(), s.size(), ec);
if(BEAST_EXPECTS(! ec, ec.message()))
if(BOOST_TEST(! ec))
{
BEAST_EXPECT(p.is_done());
BOOST_TEST(p.is_done());
f(p.get());
}
}
@ -41,18 +42,17 @@ public:
error_code ec;
number_parser p;
p.write_some(s.data(), s.size(), ec);
if(! BEAST_EXPECTS(
! ec, ec.message()))
if(! BOOST_TEST(! ec))
break;
auto n = p.write_some("x", 1, ec);
if(! BEAST_EXPECT(
if(! BOOST_TEST(
p.is_done()))
break;
if(! BEAST_EXPECT(n == 0))
if(! BOOST_TEST(n == 0))
break;
f(p.get());
p.finish(ec);
BEAST_EXPECTS(! ec, ec.message());
BOOST_TEST(! ec);
break;
}
for(size_t i = 1; i < s.size(); ++i)
@ -60,13 +60,13 @@ public:
error_code ec;
number_parser p;
p.write_some(s.data(), i, ec);
if(! BEAST_EXPECTS(! ec, ec.message()))
if(! BOOST_TEST(! ec))
continue;
p.write(
s.data() + i, s.size() - i, ec);
if(! BEAST_EXPECTS(! ec, ec.message()))
if(! BOOST_TEST(! ec))
continue;
BEAST_EXPECT(p.is_done());
BOOST_TEST(p.is_done());
f(p.get());
}
}
@ -78,7 +78,7 @@ public:
{
number_parser p;
p.write(s.data(), s.size(), xec);
BEAST_EXPECT(xec);
BOOST_TEST(xec);
}
for(size_t i = 1; i < s.size(); ++i)
{
@ -87,14 +87,14 @@ public:
p.write_some(s.data(), i, ec);
if(ec == xec)
{
BEAST_PASS();
BOOST_TEST_PASS();
continue;
}
if(! BEAST_EXPECTS(! ec, ec.message()))
if(! BOOST_TEST(! ec))
continue;
p.write(
s.data() + i, s.size() - i, ec);
BEAST_EXPECT(ec == xec);
BOOST_TEST(ec == xec);
}
}
@ -106,9 +106,9 @@ public:
grind(s,
[&](detail::number num)
{
if( BEAST_EXPECT(
if( BOOST_TEST(
num.kind == kind::int64))
BEAST_EXPECT(num.i == i);
BOOST_TEST(num.i == i);
});
}
@ -120,9 +120,9 @@ public:
grind(s,
[&](detail::number num)
{
if( BEAST_EXPECT(
if( BOOST_TEST(
num.kind == kind::uint64))
BEAST_EXPECT(num.u == u);
BOOST_TEST(num.u == u);
});
}
@ -134,9 +134,9 @@ public:
grind(s,
[&](detail::number num)
{
if( BEAST_EXPECT(
if( BOOST_TEST(
num.kind == kind::double_))
BEAST_EXPECT(num.d == d);
BOOST_TEST(num.d == d);
});
}
@ -293,24 +293,24 @@ public:
// maybe_init
{
number_parser p;
BEAST_EXPECT(! p.maybe_init(0));
BEAST_EXPECT(! p.maybe_init('A'));
BEAST_EXPECT(! p.maybe_init('a'));
BEAST_EXPECT(! p.maybe_init('.'));
BEAST_EXPECT(! p.maybe_init('!'));
BEAST_EXPECT(! p.maybe_init(' '));
BEAST_EXPECT(p.maybe_init('0')); p.reset();
BEAST_EXPECT(p.maybe_init('1')); p.reset();
BEAST_EXPECT(p.maybe_init('2')); p.reset();
BEAST_EXPECT(p.maybe_init('3')); p.reset();
BEAST_EXPECT(p.maybe_init('4')); p.reset();
BEAST_EXPECT(p.maybe_init('5')); p.reset();
BEAST_EXPECT(p.maybe_init('6')); p.reset();
BEAST_EXPECT(p.maybe_init('7')); p.reset();
BEAST_EXPECT(p.maybe_init('8')); p.reset();
BEAST_EXPECT(p.maybe_init('9')); p.reset();
BEAST_EXPECT(p.maybe_init('0')); p.reset();
BEAST_EXPECT(p.maybe_init('-')); p.reset();
BOOST_TEST(! p.maybe_init(0));
BOOST_TEST(! p.maybe_init('A'));
BOOST_TEST(! p.maybe_init('a'));
BOOST_TEST(! p.maybe_init('.'));
BOOST_TEST(! p.maybe_init('!'));
BOOST_TEST(! p.maybe_init(' '));
BOOST_TEST(p.maybe_init('0')); p.reset();
BOOST_TEST(p.maybe_init('1')); p.reset();
BOOST_TEST(p.maybe_init('2')); p.reset();
BOOST_TEST(p.maybe_init('3')); p.reset();
BOOST_TEST(p.maybe_init('4')); p.reset();
BOOST_TEST(p.maybe_init('5')); p.reset();
BOOST_TEST(p.maybe_init('6')); p.reset();
BOOST_TEST(p.maybe_init('7')); p.reset();
BOOST_TEST(p.maybe_init('8')); p.reset();
BOOST_TEST(p.maybe_init('9')); p.reset();
BOOST_TEST(p.maybe_init('0')); p.reset();
BOOST_TEST(p.maybe_init('-')); p.reset();
}
// finish
@ -318,25 +318,23 @@ public:
error_code ec;
number_parser p;
p.write_some("0x", 2, ec);
if(BEAST_EXPECTS(! ec,
ec.message()))
if(BOOST_TEST(! ec))
{
p.finish(ec);
BEAST_EXPECTS(! ec,
ec.message());
BOOST_TEST(! ec);
}
}
}
void
run() override
run()
{
testParse();
testMembers();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,number_parser);
TEST_SUITE(number_parser_test, "boost.json.detail.number_parser");
} // detail
} // json

355
test/array.cpp
View File

@ -10,14 +10,13 @@
// Test that header file is self-contained.
#include <boost/json/array.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class array_test : public beast::unit_test::suite
class array_test
{
public:
using init_list =
@ -44,10 +43,10 @@ public:
void
check(array const& a)
{
BEAST_EXPECT(a.size() == 3);
BEAST_EXPECT(a[0].is_number());
BEAST_EXPECT(a[1].is_bool());
BEAST_EXPECT(a[2].is_string());
BOOST_TEST(a.size() == 3);
BOOST_TEST(a[0].is_number());
BOOST_TEST(a[1].is_bool());
BOOST_TEST(a[2].is_string());
}
void
@ -70,8 +69,8 @@ public:
// array()
{
array a;
BEAST_EXPECT(a.empty());
BEAST_EXPECT(a.size() == 0);
BOOST_TEST(a.empty());
BOOST_TEST(a.size() == 0);
}
// array(storage_ptr)
@ -85,9 +84,9 @@ public:
// default storage
{
array a(3, true);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
for(auto const& v : a)
BEAST_EXPECT(v.is_bool());
BOOST_TEST(v.is_bool());
check_storage(a, storage_ptr{});
}
@ -100,7 +99,7 @@ public:
fail_loop([&](storage_ptr const& sp)
{
array a(3, true, sp);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
check_storage(a, sp);
});
}
@ -110,18 +109,18 @@ public:
// default storage
{
array a(3);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
for(auto const& v : a)
BEAST_EXPECT(v.is_null());
BOOST_TEST(v.is_null());
check_storage(a, storage_ptr{});
}
fail_loop([&](storage_ptr const& sp)
{
array a(3, sp);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
for(auto const& v : a)
BEAST_EXPECT(v.is_null());
BOOST_TEST(v.is_null());
check_storage(a, sp);
});
}
@ -133,11 +132,11 @@ public:
init_list init{ 0, 1, str_, 3, 4 };
array a(init.begin(), init.end());
check_storage(a, storage_ptr{});
BEAST_EXPECT(a[0].as_int64() == 0);
BEAST_EXPECT(a[1].as_int64() == 1);
BEAST_EXPECT(a[2].as_string() == str_);
BEAST_EXPECT(a[3].as_int64() == 3);
BEAST_EXPECT(a[4].as_int64() == 4);
BOOST_TEST(a[0].as_int64() == 0);
BOOST_TEST(a[1].as_int64() == 1);
BOOST_TEST(a[2].as_string() == str_);
BOOST_TEST(a[3].as_int64() == 3);
BOOST_TEST(a[4].as_int64() == 4);
}
// random iterator
@ -198,7 +197,7 @@ public:
init_list init{ 1, true, str_ };
array a1(init.begin(), init.end());
array a2(pilfer(a1));
BEAST_EXPECT(a1.empty());
BOOST_TEST(a1.empty());
check(a2);
check_storage(a2, storage_ptr{});
}
@ -208,7 +207,7 @@ public:
init_list init{ 1, true, str_ };
array a1(init.begin(), init.end());
array a2 = std::move(a1);
BEAST_EXPECT(a1.empty());
BOOST_TEST(a1.empty());
check(a2);
check_storage(a2, storage_ptr{});
}
@ -220,7 +219,7 @@ public:
array a1(init.begin(), init.end());
array a2(
std::move(a1), storage_ptr{});
BEAST_EXPECT(a1.empty());
BOOST_TEST(a1.empty());
check(a2);
check_storage(a1, storage_ptr{});
check_storage(a2, storage_ptr{});
@ -231,7 +230,7 @@ public:
init_list init{ 1, true, str_ };
array a1(init.begin(), init.end());
array a2(std::move(a1), sp);
BEAST_EXPECT(! a1.empty());
BOOST_TEST(! a1.empty());
check(a2);
check_storage(a1, storage_ptr{});
check_storage(a2, sp);
@ -298,7 +297,7 @@ public:
array a1({1, true, str_});
array a2({nullptr, object{}, 1.f});
a2 = std::move(a1);
BEAST_EXPECT(a1.empty());
BOOST_TEST(a1.empty());
check(a2);
}
@ -307,8 +306,8 @@ public:
array a1;
array a2;
a2 = std::move(a1);
BEAST_EXPECT(a1.empty());
BEAST_EXPECT(a2.empty());
BOOST_TEST(a1.empty());
BOOST_TEST(a2.empty());
}
fail_loop([&](storage_ptr const& sp)
@ -369,85 +368,85 @@ public:
// at(pos)
{
array a({1, true, str_});
BEAST_EXPECT(a.at(0).is_number());
BEAST_EXPECT(a.at(1).is_bool());
BEAST_EXPECT(a.at(2).is_string());
BOOST_TEST(a.at(0).is_number());
BOOST_TEST(a.at(1).is_bool());
BOOST_TEST(a.at(2).is_string());
try
{
a.at(3);
BEAST_FAIL();
BOOST_TEST_FAIL();
}
catch(std::out_of_range const&)
{
BEAST_PASS();
BOOST_TEST_PASS();
}
}
// at(pos) const
{
array const a({1, true, str_});
BEAST_EXPECT(a.at(0).is_number());
BEAST_EXPECT(a.at(1).is_bool());
BEAST_EXPECT(a.at(2).is_string());
BOOST_TEST(a.at(0).is_number());
BOOST_TEST(a.at(1).is_bool());
BOOST_TEST(a.at(2).is_string());
try
{
a.at(3);
BEAST_FAIL();
BOOST_TEST_FAIL();
}
catch(std::out_of_range const&)
{
BEAST_PASS();
BOOST_TEST_PASS();
}
}
// operator[&](size_type)
{
array a({1, true, str_});
BEAST_EXPECT(a[0].is_number());
BEAST_EXPECT(a[1].is_bool());
BEAST_EXPECT(a[2].is_string());
BOOST_TEST(a[0].is_number());
BOOST_TEST(a[1].is_bool());
BOOST_TEST(a[2].is_string());
}
// operator[&](size_type) const
{
array const a({1, true, str_});
BEAST_EXPECT(a[0].is_number());
BEAST_EXPECT(a[1].is_bool());
BEAST_EXPECT(a[2].is_string());
BOOST_TEST(a[0].is_number());
BOOST_TEST(a[1].is_bool());
BOOST_TEST(a[2].is_string());
}
// front()
{
array a({1, true, str_});
BEAST_EXPECT(a.front().is_number());
BOOST_TEST(a.front().is_number());
}
// front() const
{
array const a({1, true, str_});
BEAST_EXPECT(a.front().is_number());
BOOST_TEST(a.front().is_number());
}
// back()
{
array a({1, true, str_});
BEAST_EXPECT(a.back().is_string());
BOOST_TEST(a.back().is_string());
}
// back() const
{
array const a({1, true, str_});
BEAST_EXPECT(a.back().is_string());
BOOST_TEST(a.back().is_string());
}
// data()
{
{
array a({1, true, str_});
BEAST_EXPECT(a.data() == &a[0]);
BOOST_TEST(a.data() == &a[0]);
}
{
BEAST_EXPECT(array{}.data() == nullptr);
BOOST_TEST(array{}.data() == nullptr);
}
}
@ -455,11 +454,11 @@ public:
{
{
array const a({1, true, str_});
BEAST_EXPECT(a.data() == &a[0]);
BOOST_TEST(a.data() == &a[0]);
}
{
array const a{};
BEAST_EXPECT(a.data() == nullptr);
BOOST_TEST(a.data() == nullptr);
}
}
}
@ -472,104 +471,104 @@ public:
{
auto it = a.begin();
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it == a.end());
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it == a.end());
}
{
auto it = a.cbegin();
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it == a.cend());
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it == a.cend());
}
{
auto it = ac.begin();
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it == ac.end());
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it == ac.end());
}
{
auto it = a.end();
--it; BEAST_EXPECT(it->is_string());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_number());
BEAST_EXPECT(it == a.begin());
--it; BOOST_TEST(it->is_string());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_number());
BOOST_TEST(it == a.begin());
}
{
auto it = a.cend();
--it; BEAST_EXPECT(it->is_string());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_number());
BEAST_EXPECT(it == a.cbegin());
--it; BOOST_TEST(it->is_string());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_number());
BOOST_TEST(it == a.cbegin());
}
{
auto it = ac.end();
--it; BEAST_EXPECT(it->is_string());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_number());
BEAST_EXPECT(it == ac.begin());
--it; BOOST_TEST(it->is_string());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_number());
BOOST_TEST(it == ac.begin());
}
{
auto it = a.rbegin();
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it == a.rend());
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it == a.rend());
}
{
auto it = a.crbegin();
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it == a.crend());
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it == a.crend());
}
{
auto it = ac.rbegin();
BEAST_EXPECT(it->is_string()); ++it;
BEAST_EXPECT(it->is_bool()); it++;
BEAST_EXPECT(it->is_number()); ++it;
BEAST_EXPECT(it == ac.rend());
BOOST_TEST(it->is_string()); ++it;
BOOST_TEST(it->is_bool()); it++;
BOOST_TEST(it->is_number()); ++it;
BOOST_TEST(it == ac.rend());
}
{
auto it = a.rend();
--it; BEAST_EXPECT(it->is_number());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_string());
BEAST_EXPECT(it == a.rbegin());
--it; BOOST_TEST(it->is_number());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_string());
BOOST_TEST(it == a.rbegin());
}
{
auto it = a.crend();
--it; BEAST_EXPECT(it->is_number());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_string());
BEAST_EXPECT(it == a.crbegin());
--it; BOOST_TEST(it->is_number());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_string());
BOOST_TEST(it == a.crbegin());
}
{
auto it = ac.rend();
--it; BEAST_EXPECT(it->is_number());
it--; BEAST_EXPECT(it->is_bool());
--it; BEAST_EXPECT(it->is_string());
BEAST_EXPECT(it == ac.rbegin());
--it; BOOST_TEST(it->is_number());
it--; BOOST_TEST(it->is_bool());
--it; BOOST_TEST(it->is_string());
BOOST_TEST(it == ac.rbegin());
}
{
array a2;
array const& ca2(a2);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
a2.begin(), a2.end()) == 0);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
ca2.begin(), ca2.end()) == 0);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
ca2.cbegin(), ca2.cend()) == 0);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
a2.rbegin(), a2.rend()) == 0);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
ca2.rbegin(), ca2.rend()) == 0);
BEAST_EXPECT(std::distance(
BOOST_TEST(std::distance(
ca2.crbegin(), ca2.crend()) == 0);
}
}
@ -581,32 +580,32 @@ public:
{
{
array a;
BEAST_EXPECT(a.empty());
BOOST_TEST(a.empty());
a.emplace_back(1);
BEAST_EXPECT(! a.empty());
BOOST_TEST(! a.empty());
}
{
array a({1, 2});
BEAST_EXPECT(! a.empty());
BOOST_TEST(! a.empty());
a.clear();
BEAST_EXPECT(a.empty());
BEAST_EXPECT(a.capacity() > 0);
BOOST_TEST(a.empty());
BOOST_TEST(a.capacity() > 0);
}
}
// size()
{
array a;
BEAST_EXPECT(a.size() == 0);
BOOST_TEST(a.size() == 0);
a.emplace_back(1);
BEAST_EXPECT(a.size() == 1);
BOOST_TEST(a.size() == 1);
}
// max_size()
{
array a;
BEAST_EXPECT(a.max_size() > 0);
BOOST_TEST(a.max_size() > 0);
}
// reserve()
@ -629,7 +628,7 @@ public:
{
array a;
a.reserve(50);
BEAST_EXPECT(a.capacity() >= 50);
BOOST_TEST(a.capacity() >= 50);
}
fail_loop([&](storage_ptr const& sp)
@ -637,16 +636,16 @@ public:
array a(min_capacity_, 'c', sp);
a.reserve(a.capacity() + 1);
auto const new_cap = a.capacity();
BEAST_EXPECT(new_cap > min_capacity_);
BOOST_TEST(new_cap > min_capacity_);
a.reserve((min_capacity_ + new_cap) / 2);
BEAST_EXPECT(a.capacity() == new_cap);
BOOST_TEST(a.capacity() == new_cap);
});
}
// capacity()
{
array a;
BEAST_EXPECT(a.capacity() == 0);
BOOST_TEST(a.capacity() == 0);
}
// shrink_to_fit()
@ -654,16 +653,16 @@ public:
{
array a(1);
a.shrink_to_fit();
BEAST_EXPECT(a.size() == 1);
BEAST_EXPECT(a.capacity() >= 1);
BOOST_TEST(a.size() == 1);
BOOST_TEST(a.capacity() >= 1);
}
{
array a(min_capacity_, 'c');
BEAST_EXPECT(a.capacity() >= min_capacity_);
BOOST_TEST(a.capacity() >= min_capacity_);
a.erase(a.begin(), a.begin() + 2);
a.shrink_to_fit();
BEAST_EXPECT(a.capacity() == min_capacity_);
BOOST_TEST(a.capacity() == min_capacity_);
}
fail_loop([&](storage_ptr const& sp)
@ -671,23 +670,23 @@ public:
array a(1, sp);
a.resize(a.capacity());
a.shrink_to_fit();
BEAST_EXPECT(a.size() == a.capacity());
BOOST_TEST(a.size() == a.capacity());
});
fail_loop([&](storage_ptr const& sp)
{
array a(sp);
a.reserve(10);
BEAST_EXPECT(a.capacity() >= 10);
BOOST_TEST(a.capacity() >= 10);
a.shrink_to_fit();
BEAST_EXPECT(a.capacity() == 0);
BOOST_TEST(a.capacity() == 0);
});
fail_loop([&](storage_ptr const& sp)
{
array a(min_capacity_, sp);
a.reserve(min_capacity_ * 2);
BEAST_EXPECT(a.capacity() >=
BOOST_TEST(a.capacity() >=
min_capacity_ * 2);
a.shrink_to_fit();
if(a.capacity() > min_capacity_)
@ -703,17 +702,17 @@ public:
{
{
array a;
BEAST_EXPECT(a.size() == 0);
BEAST_EXPECT(a.capacity() == 0);
BOOST_TEST(a.size() == 0);
BOOST_TEST(a.capacity() == 0);
a.clear();
BEAST_EXPECT(a.size() == 0);
BEAST_EXPECT(a.capacity() == 0);
BOOST_TEST(a.size() == 0);
BOOST_TEST(a.capacity() == 0);
}
{
array a({1, true, str_});
a.clear();
BEAST_EXPECT(a.size() == 0);
BEAST_EXPECT(a.capacity() > 0);
BOOST_TEST(a.size() == 0);
BOOST_TEST(a.capacity() > 0);
}
}
@ -744,11 +743,11 @@ public:
value v({1,2,3});
array a({1, str_}, sp);
a.insert(a.begin() + 1, 3, v);
BEAST_EXPECT(a[0].is_number());
BEAST_EXPECT(a[1].as_array().size() == 3);
BEAST_EXPECT(a[2].as_array().size() == 3);
BEAST_EXPECT(a[3].as_array().size() == 3);
BEAST_EXPECT(a[4].is_string());
BOOST_TEST(a[0].is_number());
BOOST_TEST(a[1].as_array().size() == 3);
BOOST_TEST(a[2].as_array().size() == 3);
BOOST_TEST(a[3].as_array().size() == 3);
BOOST_TEST(a[4].is_string());
});
// insert(const_iterator, InputIt, InputIt)
@ -772,7 +771,7 @@ public:
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
17, 18, 19, 20, 21, 22, 23, 24, 25, 26,
27, 28, 29, 30 };
BEAST_EXPECT(init.size() > min_capacity_);
BOOST_TEST(init.size() > min_capacity_);
array a(sp);
a.insert(a.begin(),
init.begin(), init.end());
@ -785,7 +784,7 @@ public:
a.insert(a.begin(),
make_input_iterator(init.begin()),
make_input_iterator(init.end()));
BEAST_EXPECT(a.empty());
BOOST_TEST(a.empty());
}
// input iterator
@ -809,7 +808,7 @@ public:
a.insert(a.begin(),
make_input_iterator(init.begin()),
make_input_iterator(init.end()));
BEAST_EXPECT(a.size() == init.size() + 1);
BOOST_TEST(a.size() == init.size() + 1);
});
// backward relocate
@ -829,12 +828,12 @@ public:
array a({0, 3, 4}, sp);
auto it = a.insert(
a.begin() + 1, {1, str_});
BEAST_EXPECT(it == a.begin() + 1);
BEAST_EXPECT(a[0].as_int64() == 0);
BEAST_EXPECT(a[1].as_int64() == 1);
BEAST_EXPECT(a[2].as_string() == str_);
BEAST_EXPECT(a[3].as_int64() == 3);
BEAST_EXPECT(a[4].as_int64() == 4);
BOOST_TEST(it == a.begin() + 1);
BOOST_TEST(a[0].as_int64() == 0);
BOOST_TEST(a[1].as_int64() == 1);
BOOST_TEST(a[2].as_string() == str_);
BOOST_TEST(a[3].as_int64() == 3);
BOOST_TEST(a[4].as_int64() == 4);
});
// emplace(const_iterator, arg)
@ -843,12 +842,12 @@ public:
array a({0, 2, 3, 4}, sp);
auto it = a.emplace(
a.begin() + 1, str_);
BEAST_EXPECT(it == a.begin() + 1);
BEAST_EXPECT(a[0].as_int64() == 0);
BEAST_EXPECT(a[1].as_string() == str_);
BEAST_EXPECT(a[2].as_int64() == 2);
BEAST_EXPECT(a[3].as_int64() == 3);
BEAST_EXPECT(a[4].as_int64() == 4);
BOOST_TEST(it == a.begin() + 1);
BOOST_TEST(a[0].as_int64() == 0);
BOOST_TEST(a[1].as_string() == str_);
BOOST_TEST(a[2].as_int64() == 2);
BOOST_TEST(a[3].as_int64() == 3);
BOOST_TEST(a[4].as_int64() == 4);
});
// erase(pos)
@ -873,7 +872,7 @@ public:
array a({1, true}, sp);
value v(str_);
a.push_back(v);
BEAST_EXPECT(
BOOST_TEST(
v.as_string() == str_);
check(a);
check_storage(a, sp);
@ -920,7 +919,7 @@ public:
{
array a(5, sp);
a.resize(3);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
check_storage(a, sp);
});
@ -928,7 +927,7 @@ public:
{
array a(sp);
a.resize(3);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
check_storage(a, sp);
});
}
@ -944,7 +943,7 @@ public:
{
array a(5, v, sp);
a.resize(3, v);
BEAST_EXPECT(a.size() == 3);
BOOST_TEST(a.size() == 3);
check_storage(a, sp);
});
@ -952,7 +951,7 @@ public:
{
array a(3, v, sp);
a.resize(5, v);
BEAST_EXPECT(a.size() == 5);
BOOST_TEST(a.size() == 5);
check_storage(a, sp);
});
}
@ -965,9 +964,9 @@ public:
array a2 = {1.};
a1.swap(a2);
check(a2);
BEAST_EXPECT(a1.size() == 1);
BEAST_EXPECT(a1.front().is_number());
BEAST_EXPECT(a1.front().as_double() == 1.);
BOOST_TEST(a1.size() == 1);
BOOST_TEST(a1.front().is_number());
BOOST_TEST(a1.front().as_double() == 1.);
}
// different storage
@ -977,7 +976,7 @@ public:
array a2 = {1.};
a1.swap(a2);
check(a2);
BEAST_EXPECT(a1.size() == 1);
BOOST_TEST(a1.size() == 1);
});
fail_loop([&](storage_ptr const& sp)
{
@ -985,7 +984,7 @@ public:
array a2({1, true, str_}, sp);
a1.swap(a2);
check(a1);
BEAST_EXPECT(a2.size() == 1);
BOOST_TEST(a2.size() == 1);
});
}
}
@ -1025,12 +1024,12 @@ public:
a.insert(a.begin() + 1,
3, nullptr);
a1 = a;
BEAST_EXPECT(a1.size() == 5);
BEAST_EXPECT(a1[0].is_number());
BEAST_EXPECT(a1[1].is_null());
BEAST_EXPECT(a1[2].is_null());
BEAST_EXPECT(a1[3].is_null());
BEAST_EXPECT(a1[4].is_bool());
BOOST_TEST(a1.size() == 5);
BOOST_TEST(a1[0].is_number());
BOOST_TEST(a1[1].is_null());
BOOST_TEST(a1[2].is_null());
BOOST_TEST(a1[3].is_null());
BOOST_TEST(a1[4].is_bool());
});
// insert(const_iterator, InputIt, InputIt)
@ -1052,10 +1051,10 @@ public:
array a({1, nullptr}, sp);
a.emplace(a.begin() + 1, true);
a1 = a;
BEAST_EXPECT(a1.size() == 3);
BEAST_EXPECT(a1[0].is_number());
BEAST_EXPECT(a1[1].is_bool());
BEAST_EXPECT(a1[2].is_null());
BOOST_TEST(a1.size() == 3);
BOOST_TEST(a1[0].is_number());
BOOST_TEST(a1[1].is_bool());
BOOST_TEST(a1[2].is_null());
});
// emplace(const_iterator, arg)
@ -1066,15 +1065,15 @@ public:
a.emplace(a.begin() + 1, true);
a1 = a;
check(a1);
BEAST_EXPECT(a1.size() == 3);
BEAST_EXPECT(a1[0].is_number());
BEAST_EXPECT(a1[1].is_bool());
BEAST_EXPECT(a1[2].is_string());
BOOST_TEST(a1.size() == 3);
BOOST_TEST(a1[0].is_number());
BOOST_TEST(a1[1].is_bool());
BOOST_TEST(a1[2].is_string());
});
}
void
run() override
run()
{
testCtors();
testAssignment();
@ -1087,7 +1086,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,array);
TEST_SUITE(array_test, "boost.json.array");
} // json
} // boost

107
test/basic_parser.cpp
View File

@ -10,13 +10,13 @@
// Test that header file is self-contained.
#include <boost/json/basic_parser.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <memory>
#include <string>
#include <utility>
#include "test.hpp"
#include "parse-vectors.hpp"
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
@ -140,9 +140,11 @@ validate( string_view s )
} // (anon)
class basic_parser_test : public beast::unit_test::suite
class basic_parser_test
{
public:
::test_suite::log_type log;
void
split_grind(
string_view s,
@ -153,7 +155,7 @@ public:
for(std::size_t i = 1;
i < s.size(); ++i)
{
if(! BEAST_EXPECT(i < 100000))
if(! BOOST_TEST(i < 100000))
break;
error_code ec;
fail_parser p;
@ -161,8 +163,7 @@ public:
p.write_some(s.data(), i, ec);
if(ec)
{
BEAST_EXPECTS(ec == ex,
ec.message());
BOOST_TEST(ec == ex);
continue;
}
p.write(
@ -170,8 +171,7 @@ public:
s.size() - n, ec);
if(! ec)
p.finish(ec);
if(! BEAST_EXPECTS(ec == ex,
ec.message()))
if(! BOOST_TEST(ec == ex))
log << "should be " << ex.message() << std::endl;
}
}
@ -184,7 +184,7 @@ public:
// exercise all error paths
for(std::size_t j = 1;;++j)
{
if(! BEAST_EXPECT(j < 100000))
if(! BOOST_TEST(j < 100000))
break;
error_code ec;
fail_parser p(j);
@ -194,8 +194,7 @@ public:
p.finish(ec);
if(ec == error::test_failure)
continue;
BEAST_EXPECTS(ec == ex,
ec.message());
BOOST_TEST(ec == ex);
break;
}
}
@ -208,7 +207,7 @@ public:
// exercise all exception paths
for(std::size_t j = 1;;++j)
{
if(! BEAST_EXPECT(j < 100000))
if(! BOOST_TEST(j < 100000))
break;
error_code ec;
throw_parser p(j);
@ -218,8 +217,7 @@ public:
s.data(), s.size(), ec);
if(! ec)
p.finish(ec);
BEAST_EXPECTS(ec == ex,
ec.message());
BOOST_TEST(ec == ex);
break;
}
catch(test_exception const&)
@ -228,7 +226,7 @@ public:
}
catch(std::exception const& e)
{
BEAST_FAIL();
BOOST_TEST_FAIL();
log << " " <<
e.what() << std::endl;
}
@ -249,13 +247,12 @@ public:
p.finish(ex);
if(good)
{
if(! BEAST_EXPECTS(
! ex, ex.message()))
if(! BOOST_TEST(! ex))
return;
}
else
{
if(! BEAST_EXPECT(ex))
if(! BOOST_TEST(ex))
return;
}
}
@ -483,10 +480,9 @@ public:
p.write_some(
s.data(), s.size(),
ec);
if(! BEAST_EXPECTS(! ec,
ec.message()))
if(! BOOST_TEST(! ec))
return;
BEAST_EXPECT(is_done ==
BOOST_TEST(is_done ==
p.is_done());
};
@ -537,43 +533,40 @@ public:
{
error_code ec;
fail_parser p;
BEAST_EXPECT(
BOOST_TEST(
p.depth() == 0);
BEAST_EXPECT(
BOOST_TEST(
p.max_depth() > 0);
p.max_depth(1);
p.write("[{}]", 4, ec);
BEAST_EXPECTS(
ec == error::too_deep,
ec.message());
BEAST_EXPECT(! p.is_done());
BOOST_TEST(
ec == error::too_deep);
BOOST_TEST(! p.is_done());
}
{
error_code ec;
fail_parser p;
BEAST_EXPECT(
BOOST_TEST(
p.max_depth() > 0);
p.max_depth(1);
p.write_some("[", 1, ec);
BEAST_EXPECT(p.depth() == 1);
if(BEAST_EXPECTS(! ec,
ec.message()))
BOOST_TEST(p.depth() == 1);
if(BOOST_TEST(! ec))
{
p.write_some("{", 1, ec);
BEAST_EXPECTS(
ec == error::too_deep,
ec.message());
BOOST_TEST(
ec == error::too_deep);
}
BEAST_EXPECT(! p.is_done());
BOOST_TEST(! p.is_done());
ec = {};
p.write_some("{}", 2, ec);
BEAST_EXPECT(ec);
BOOST_TEST(ec);
p.reset();
p.write("{}", 2, ec);
if(! ec)
p.finish(ec);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(p.is_done());
BOOST_TEST(! ec);
BOOST_TEST(p.is_done());
}
}
@ -612,7 +605,7 @@ public:
error_code ec;
fail_parser p;
p.finish(ec);
BEAST_EXPECT(ec);
BOOST_TEST(ec);
}
}
@ -625,7 +618,7 @@ public:
error_code ec;
fail_parser p;
p.write_some("0", 1, ec);
BEAST_EXPECTS(! ec, ec.message());
BOOST_TEST(! ec);
}
// partial write
@ -634,15 +627,15 @@ public:
fail_parser p;
auto const n =
p.write_some("null x", 6, ec);
BEAST_EXPECTS(! ec, ec.message());
BEAST_EXPECT(n < 6);
BOOST_TEST(! ec);
BOOST_TEST(n < 6);
}
}
// write_some(char const*, size_t)
{
fail_parser p;
BEAST_THROWS(
BOOST_TEST_THROWS(
p.write_some("x", 1),
system_error);
}
@ -652,9 +645,8 @@ public:
error_code ec;
fail_parser p;
p.write("0x", 2, ec);
BEAST_EXPECTS(
ec == error::extra_data,
ec.message());
BOOST_TEST(
ec == error::extra_data);
}
// write(char const*, size_t)
@ -666,7 +658,7 @@ public:
{
fail_parser p;
BEAST_THROWS(
BOOST_TEST_THROWS(
p.write("0x", 2),
system_error);
}
@ -677,9 +669,8 @@ public:
error_code ec;
fail_parser p;
p.finish("{", 1, ec);
BEAST_EXPECTS(
ec == error::incomplete,
ec.message());
BOOST_TEST(
ec == error::incomplete);
}
// finish(char const*, size_t)
@ -691,7 +682,7 @@ public:
{
fail_parser p;
BEAST_THROWS(
BOOST_TEST_THROWS(
p.finish("{", 1),
system_error);
}
@ -702,16 +693,16 @@ public:
{
fail_parser p;
p.write("{}", 2);
BEAST_EXPECT(! p.is_done());
BOOST_TEST(! p.is_done());
p.finish();
BEAST_EXPECT(p.is_done());
BOOST_TEST(p.is_done());
}
{
fail_parser p;
p.write("{", 1);
BEAST_EXPECT(! p.is_done());
BEAST_THROWS(
BOOST_TEST(! p.is_done());
BOOST_TEST_THROWS(
p.finish(),
system_error);
}
@ -797,11 +788,11 @@ public:
base64::decode(
p.get(), s.data(), s.size());
string_view const js(p.get(), len);
BEAST_EXPECT(! validate(js));
BOOST_TEST(! validate(js));
}
void
run() override
run()
{
testObject();
testArray();
@ -818,7 +809,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,basic_parser);
TEST_SUITE(basic_parser_test, "boost.json.basic_parser");
} // json
} // boost

27
test/error.cpp
View File

@ -10,21 +10,22 @@
// Test that header file is self-contained.
#include <boost/json/error.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <memory>
#include "test_suite.hpp"
namespace boost {
namespace json {
class error_test : public beast::unit_test::suite
class error_test
{
public:
void check(error e)
{
auto const ec = make_error_code(e);
BEAST_EXPECT(ec.category().name() != nullptr);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(ec.category().default_error_condition(
BOOST_TEST(ec.category().name() != nullptr);
BOOST_TEST(! ec.message().empty());
BOOST_TEST(ec.category().default_error_condition(
static_cast<int>(e)).category() == ec.category());
}
@ -32,20 +33,20 @@ public:
{
{
auto const ec = make_error_code(e);
BEAST_EXPECT(ec.category().name() != nullptr);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(ec == c);
BOOST_TEST(ec.category().name() != nullptr);
BOOST_TEST(! ec.message().empty());
BOOST_TEST(ec == c);
}
{
auto ec = make_error_condition(c);
BEAST_EXPECT(ec.category().name() != nullptr);
BEAST_EXPECT(! ec.message().empty());
BEAST_EXPECT(ec == c);
BOOST_TEST(ec.category().name() != nullptr);
BOOST_TEST(! ec.message().empty());
BOOST_TEST(ec == c);
}
}
void
run() override
run()
{
check(condition::parse_error, error::syntax);
check(condition::parse_error, error::extra_data);
@ -88,7 +89,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,error);
TEST_SUITE(error_test, "boost.json.error");
} // json
} // boost

20
test/json.cpp
View File

@ -10,16 +10,18 @@
// Test that header file is self-contained.
#include <boost/json.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test_suite.hpp"
namespace boost {
namespace json {
struct zjson_test : public beast::unit_test::suite
struct json_test
{
::test_suite::log_type log;
void
run() override
run()
{
using namespace json;
log <<
"sizeof(alignof)\n"
" object == " << sizeof(object) << " (" << alignof(object) << ")\n"
@ -28,16 +30,14 @@ struct zjson_test : public beast::unit_test::suite
" string == " << sizeof(string) << " (" << alignof(string) << ")\n"
" value == " << sizeof(value) << " (" << alignof(value) << ")\n"
" serializer == " << sizeof(serializer) << "\n"
" number_parser == " << sizeof(detail::number_parser) << "\n"
" number_parser == " << sizeof(json::detail::number_parser) << "\n"
" basic_parser == " << sizeof(basic_parser) << "\n"
" parser == " << sizeof(parser) << "\n"
<< std::endl;
" parser == " << sizeof(parser)
;
pass();
BOOST_TEST_PASS();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,zjson);
TEST_SUITE(json_test, "boost.json.zsizes");
} // json
} // boost

11
test/kind.cpp
View File

@ -10,13 +10,14 @@
// Test that header file is self-contained.
#include <boost/json/kind.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <type_traits>
#include "test_suite.hpp"
namespace boost {
namespace json {
class kind_test : public beast::unit_test::suite
class kind_test
{
public:
BOOST_STATIC_ASSERT(
@ -25,16 +26,16 @@ public:
void
testEnum()
{
pass();
BOOST_TEST_PASS();
}
void run() override
void run()
{
testEnum();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,kind);
TEST_SUITE(kind_test, "boost.json.kind");
} // json
} // boost

49
test/limits.cpp
View File

@ -13,10 +13,11 @@
#include <boost/json/value.hpp>
#include <boost/json/parser.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test.hpp"
#include <vector>
#include "test_suite.hpp"
#include "test.hpp"
namespace boost {
namespace json {
@ -26,7 +27,7 @@ namespace json {
length.
*/
class limits_test : public beast::unit_test::suite
class limits_test
{
public:
void
@ -43,8 +44,8 @@ public:
{"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
{"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
{"31",31}};
BEAST_EXPECT(init.size() > object::max_size());
BEAST_THROWS(value{init}, std::length_error);
BOOST_TEST(init.size() > object::max_size());
BOOST_TEST_THROWS(value{init}, std::length_error);
}
}
@ -53,7 +54,7 @@ public:
{
// max size
{
BEAST_THROWS(
BOOST_TEST_THROWS(
object(object::max_size()+1),
std::length_error);
}
@ -69,11 +70,11 @@ public:
{"21",21},{"22",22},{"23",23},{"24",24},{"25",25},
{"26",26},{"27",27},{"28",28},{"29",29},{"30",30},
{"31",31}};
BEAST_EXPECT(init.size() > object::max_size());
BEAST_THROWS(
BOOST_TEST(init.size() > object::max_size());
BOOST_TEST_THROWS(
object(init.begin(), init.end()),
std::length_error);
BEAST_THROWS(
BOOST_TEST_THROWS(
object(
make_input_iterator(init.begin()),
make_input_iterator(init.end())),
@ -84,7 +85,7 @@ public:
{
std::string const big(
string::max_size() + 1, '*');
BEAST_THROWS(
BOOST_TEST_THROWS(
object({ {big, nullptr} }),
std::length_error);
}
@ -94,7 +95,7 @@ public:
testArray()
{
{
BEAST_THROWS(
BOOST_TEST_THROWS(
array(
array::max_size()+1,
value(nullptr)),
@ -104,7 +105,7 @@ public:
{
std::vector<int> v(
array::max_size()+1, 42);
BEAST_THROWS(
BOOST_TEST_THROWS(
array(v.begin(), v.end()),
std::length_error);
}
@ -112,7 +113,7 @@ public:
{
std::vector<int> v(
array::max_size()+1, 42);
BEAST_THROWS(array(
BOOST_TEST_THROWS(array(
make_input_iterator(v.begin()),
make_input_iterator(v.end())),
std::length_error);
@ -120,7 +121,7 @@ public:
{
array a;
BEAST_THROWS(
BOOST_TEST_THROWS(
a.insert(a.begin(),
array::max_size() + 1,
nullptr),
@ -135,7 +136,7 @@ public:
{
{
string s;
BEAST_THROWS(
BOOST_TEST_THROWS(
(s.resize(s.max_size() + 1)),
std::length_error);
}
@ -143,7 +144,7 @@ public:
{
string s;
s.resize(100);
BEAST_THROWS(
BOOST_TEST_THROWS(
(s.append(s.max_size() - 1, '*')),
std::length_error);
}
@ -171,7 +172,7 @@ public:
auto const js =
"\"" + big + "\":null";
value jv;
BEAST_THROWS(
BOOST_TEST_THROWS(
jv = parse(js),
std::length_error);
}
@ -184,7 +185,7 @@ public:
auto const js =
"{\"" + big + "\":null}";
value jv;
BEAST_THROWS(
BOOST_TEST_THROWS(
jv = parse(js),
std::length_error);
}
@ -197,7 +198,7 @@ public:
{
std::string big;
value jv;
BEAST_THROWS(
BOOST_TEST_THROWS(
jv = parse(
"[1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
"1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,1,2,3,4,5,6,7,8,9,0,"
@ -231,7 +232,7 @@ public:
auto const js =
"\"" + big + "\"";
value jv;
BEAST_THROWS(jv = parse(js),
BOOST_TEST_THROWS(jv = parse(js),
decltype(detail::string_too_large_exception()));
}
@ -244,13 +245,13 @@ public:
auto const js =
"\"" + big + "\"";
value jv;
BEAST_THROWS(jv = parse(js),
BOOST_TEST_THROWS(jv = parse(js),
decltype(detail::string_too_large_exception()));
}
}
void
run() override
run()
{
#if ! defined(BOOST_JSON_NO_MAX_OBJECT_SIZE) && \
! defined(BOOST_JSON_NO_MAX_ARRAY_SIZE) && \
@ -266,12 +267,12 @@ public:
testParser();
#else
pass();
BOOST_TEST_PASS();
#endif
}
};
BEAST_DEFINE_TESTSUITE(boost,json,limits);
TEST_SUITE(limits_test, "boost.json.limits");
} // json
} // boost

23
test/main.cpp
View File

@ -7,4 +7,25 @@
// Official repository: https://github.com/vinniefalco/json
//
#include <boost/beast/_experimental/unit_test/main.ipp>
#include "test_suite.hpp"
#include <iostream>
#ifdef _MSC_VER
#include <crtdbg.h>
#endif
// Simple main used to produce stand
// alone executables that run unit tests.
int main(int argc, char const* const* argv)
{
#ifdef _MSC_VER
{
int flags = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
flags |= _CRTDBG_LEAK_CHECK_DF;
_CrtSetDbgFlag(flags);
}
#endif
::test_suite::debug_stream log(std::cerr);
return ::test_suite::run(log, argc, argv);
}

27
test/number_cast.cpp
View File

@ -10,10 +10,11 @@
// Test that header file is self-contained.
#include <boost/json/number_cast.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <type_traits>
#include <limits.h>
#include "test_suite.hpp"
namespace boost {
namespace json {
@ -35,22 +36,22 @@ T min_of()
} // (anon)
class number_cast_test : public beast::unit_test::suite
class number_cast_test
{
public:
void
testNumberCast()
{
#define EQAL(T) BEAST_EXPECT(number_cast<T>(jv) == V)
#define EQUS(T) BEAST_EXPECT((V >= 0) && number_cast<T>(jv) == static_cast<std::uint64_t>(V))
#define EQUF(T) BEAST_EXPECT(static_cast<float>(V) == static_cast<float>(number_cast<T>(jv)))
#define THRO(T) BEAST_THROWS(number_cast<T>(jv), system_error)
#define EQAL(T) BOOST_TEST(number_cast<T>(jv) == V)
#define EQUS(T) BOOST_TEST((V >= 0) && number_cast<T>(jv) == static_cast<std::uint64_t>(V))
#define EQUF(T) BOOST_TEST(static_cast<float>(V) == static_cast<float>(number_cast<T>(jv)))
#define THRO(T) BOOST_TEST_THROWS(number_cast<T>(jv), system_error)
BEAST_THROWS(number_cast<int>(value(object_kind)), system_error);
BEAST_THROWS(number_cast<int>(value(array_kind)), system_error);
BEAST_THROWS(number_cast<int>(value(string_kind)), system_error);
BEAST_THROWS(number_cast<int>(value(false)), system_error);
BEAST_THROWS(number_cast<int>(value(nullptr)), system_error);
BOOST_TEST_THROWS(number_cast<int>(value(object_kind)), system_error);
BOOST_TEST_THROWS(number_cast<int>(value(array_kind)), system_error);
BOOST_TEST_THROWS(number_cast<int>(value(string_kind)), system_error);
BOOST_TEST_THROWS(number_cast<int>(value(false)), system_error);
BOOST_TEST_THROWS(number_cast<int>(value(nullptr)), system_error);
{
unsigned char V = 0;
@ -298,13 +299,13 @@ public:
}
void
run() override
run()
{
testNumberCast();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,number_cast);
TEST_SUITE(number_cast_test, "boost.json.number_cast");
} // json
} // boost

290
test/object.cpp
View File

@ -12,16 +12,16 @@
#include <boost/json/pool.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <cmath>
#include <type_traits>
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class object_test : public beast::unit_test::suite
class object_test
{
public:
string_view const str_;
@ -108,13 +108,13 @@ public:
object const& o,
std::size_t capacity)
{
BEAST_EXPECT(! o.empty());
BEAST_EXPECT(o.size() == 3);
BEAST_EXPECT(
BOOST_TEST(! o.empty());
BOOST_TEST(o.size() == 3);
BOOST_TEST(
o.capacity() == capacity);
BEAST_EXPECT(o.at("a").as_int64() == 1);
BEAST_EXPECT(o.at("b").as_bool());
BEAST_EXPECT(o.at("c").as_string() == "hello");
BOOST_TEST(o.at("a").as_int64() == 1);
BOOST_TEST(o.at("b").as_bool());
BOOST_TEST(o.at("c").as_string() == "hello");
check_storage(o, o.storage());
}
@ -129,9 +129,9 @@ public:
// object()
{
object o;
BEAST_EXPECT(o.empty());
BEAST_EXPECT(o.size() == 0);
BEAST_EXPECT(o.capacity() == 0);
BOOST_TEST(o.empty());
BOOST_TEST(o.size() == 0);
BOOST_TEST(o.capacity() == 0);
}
// object(storage_ptr)
@ -139,27 +139,27 @@ public:
{
object o(sp);
check_storage(o, sp);
BEAST_EXPECT(o.empty());
BEAST_EXPECT(o.size() == 0);
BEAST_EXPECT(o.capacity() == 0);
BOOST_TEST(o.empty());
BOOST_TEST(o.size() == 0);
BOOST_TEST(o.capacity() == 0);
});
// object(std::size_t, storage_ptr)
{
{
object o(10);
BEAST_EXPECT(o.empty());
BEAST_EXPECT(o.size() == 0);
BEAST_EXPECT(o.capacity() >= 10);
BOOST_TEST(o.empty());
BOOST_TEST(o.size() == 0);
BOOST_TEST(o.capacity() >= 10);
}
fail_loop([&](storage_ptr const& sp)
{
object o(10, sp);
check_storage(o, sp);
BEAST_EXPECT(o.empty());
BEAST_EXPECT(o.size() == 0);
BEAST_EXPECT(o.capacity() >= 10);
BOOST_TEST(o.empty());
BOOST_TEST(o.size() == 0);
BOOST_TEST(o.capacity() >= 10);
});
}
@ -193,9 +193,9 @@ public:
{"b", true},
{"c", "hello"}};
object o(init.begin(), init.end(), 5, sp);
BEAST_EXPECT(! o.empty());
BEAST_EXPECT(o.size() == 3);
BEAST_EXPECT(o.capacity() == 7);
BOOST_TEST(! o.empty());
BOOST_TEST(o.size() == 3);
BOOST_TEST(o.capacity() == 7);
check(o, 7);
check_storage(o, sp);
});
@ -211,9 +211,9 @@ public:
make_input_iterator(init.begin()),
make_input_iterator(init.end()),
5, sp);
BEAST_EXPECT(! o.empty());
BEAST_EXPECT(o.size() == 3);
BEAST_EXPECT(o.capacity() == 7);
BOOST_TEST(! o.empty());
BOOST_TEST(o.size() == 3);
BOOST_TEST(o.capacity() == 7);
check(o, 7);
check_storage(o, sp);
});
@ -230,8 +230,8 @@ public:
auto const sp =
storage_ptr{};
object o2(std::move(o1));
BEAST_EXPECT(o1.empty());
BEAST_EXPECT(o1.size() == 0);
BOOST_TEST(o1.empty());
BOOST_TEST(o1.size() == 0);
check(o2, 3);
check_storage(o1, sp);
check_storage(o2, sp);
@ -246,7 +246,7 @@ public:
{"c", "hello"}
});
object o2(std::move(o1), sp);
BEAST_EXPECT(! o1.empty());
BOOST_TEST(! o1.empty());
check(o2, 3);
check_storage(o1,
storage_ptr{});
@ -263,11 +263,11 @@ public:
{"c", "hello"}
}, sp);
object o2(pilfer(o1));
BEAST_EXPECT(
BOOST_TEST(
o1.storage() == nullptr);
BEAST_EXPECT(
BOOST_TEST(
*o2.storage() == *sp);
BEAST_EXPECT(o1.empty());
BOOST_TEST(o1.empty());
check(o2, 3);
}
@ -282,7 +282,7 @@ public:
{"c", "hello"}
});
object o2(o1);
BEAST_EXPECT(! o1.empty());
BOOST_TEST(! o1.empty());
check(o2, 3);
}
@ -295,7 +295,7 @@ public:
{"c", "hello"}
});
object o2(o1, sp);
BEAST_EXPECT(! o1.empty());
BOOST_TEST(! o1.empty());
check(o2, 3);
check_storage(o2, sp);
});
@ -341,7 +341,7 @@ public:
{"c", "hello"}
},
5, sp);
BEAST_EXPECT(
BOOST_TEST(
*o.storage() == *sp);
check(o, 7);
});
@ -357,7 +357,7 @@ public:
object o2;
o2 = std::move(o1);
check(o2, 3);
BEAST_EXPECT(o1.empty());
BOOST_TEST(o1.empty());
check_storage(o1,
storage_ptr{});
check_storage(o2,
@ -444,7 +444,7 @@ public:
{"a", 1},
{"b", true},
{"c", "hello"} },
BEAST_EXPECT(
BOOST_TEST(
*o.storage() == *sp);
check(o, 3);
check_storage(o, sp);
@ -465,117 +465,117 @@ public:
// empty container
{
BEAST_EXPECT(no.begin() == no.end());
BEAST_EXPECT(cno.begin() == cno.end());
BEAST_EXPECT(no.cbegin() == no.cend());
BOOST_TEST(no.begin() == no.end());
BOOST_TEST(cno.begin() == cno.end());
BOOST_TEST(no.cbegin() == no.cend());
}
// begin()
{
auto it = o.begin();
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it == o.end());
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it == o.end());
}
// begin() const
{
auto it = co.begin();
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it == co.end());
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it == co.end());
}
// cbegin()
{
auto it = o.cbegin();
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it == o.cend());
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it == o.cend());
}
// end()
{
auto it = o.end();
--it; BEAST_EXPECT(it->key() == "c");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "a");
BEAST_EXPECT(it == o.begin());
--it; BOOST_TEST(it->key() == "c");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "a");
BOOST_TEST(it == o.begin());
}
// end() const
{
auto it = co.end();
--it; BEAST_EXPECT(it->key() == "c");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "a");
BEAST_EXPECT(it == co.begin());
--it; BOOST_TEST(it->key() == "c");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "a");
BOOST_TEST(it == co.begin());
}
// cend()
{
auto it = o.cend();
--it; BEAST_EXPECT(it->key() == "c");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "a");
BEAST_EXPECT(it == o.cbegin());
--it; BOOST_TEST(it->key() == "c");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "a");
BOOST_TEST(it == o.cbegin());
}
// rbegin()
{
auto it = o.rbegin();
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it == o.rend());
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it == o.rend());
}
// rbegin() const
{
auto it = co.rbegin();
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it == co.rend());
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it == co.rend());
}
// crbegin()
{
auto it = o.crbegin();
BEAST_EXPECT(it->key() == "c"); ++it;
BEAST_EXPECT(it->key() == "b"); it++;
BEAST_EXPECT(it->key() == "a"); ++it;
BEAST_EXPECT(it == o.crend());
BOOST_TEST(it->key() == "c"); ++it;
BOOST_TEST(it->key() == "b"); it++;
BOOST_TEST(it->key() == "a"); ++it;
BOOST_TEST(it == o.crend());
}
// rend()
{
auto it = o.rend();
--it; BEAST_EXPECT(it->key() == "a");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "c");
BEAST_EXPECT(it == o.rbegin());
--it; BOOST_TEST(it->key() == "a");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "c");
BOOST_TEST(it == o.rbegin());
}
// rend() const
{
auto it = co.rend();
--it; BEAST_EXPECT(it->key() == "a");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "c");
BEAST_EXPECT(it == co.rbegin());
--it; BOOST_TEST(it->key() == "a");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "c");
BOOST_TEST(it == co.rbegin());
}
// crend()
{
auto it = o.crend();
--it; BEAST_EXPECT(it->key() == "a");
it--; BEAST_EXPECT(it->key() == "b");
--it; BEAST_EXPECT(it->key() == "c");
BEAST_EXPECT(it == o.crbegin());
--it; BOOST_TEST(it->key() == "a");
it--; BOOST_TEST(it->key() == "b");
--it; BOOST_TEST(it->key() == "c");
BOOST_TEST(it == o.crbegin());
}
}
@ -584,7 +584,7 @@ public:
void
testCapacity()
{
BEAST_EXPECT(
BOOST_TEST(
object{}.size() < object{}.max_size());
}
@ -598,15 +598,15 @@ public:
{
object o;
o.clear();
BEAST_EXPECT(o.empty());
BOOST_TEST(o.empty());
}
{
object o;
o.emplace("x", 1);
BEAST_EXPECT(! o.empty());
BOOST_TEST(! o.empty());
o.clear();
BEAST_EXPECT(o.empty());
BOOST_TEST(o.empty());
}
}
@ -617,9 +617,9 @@ public:
object o(sp);
auto result = o.insert(
std::make_pair("x", 1));
BEAST_EXPECT(result.second);
BEAST_EXPECT(result.first->key() == "x");
BEAST_EXPECT(result.first->value().as_int64() == 1);
BOOST_TEST(result.second);
BOOST_TEST(result.first->key() == "x");
BOOST_TEST(result.first->value().as_int64() == 1);
});
fail_loop([&](storage_ptr const& sp)
@ -627,9 +627,9 @@ public:
object o(sp);
auto const p = std::make_pair("x", 1);
auto result = o.insert(p);
BEAST_EXPECT(result.second);
BEAST_EXPECT(result.first->key() == "x");
BEAST_EXPECT(result.first->value().as_int64() == 1);
BOOST_TEST(result.second);
BOOST_TEST(result.first->key() == "x");
BOOST_TEST(result.first->value().as_int64() == 1);
});
fail_loop([&](storage_ptr const& sp)
@ -640,9 +640,9 @@ public:
{"c", 3}}, sp);
auto const result = o.insert(
std::make_pair("b", 4));
BEAST_EXPECT(
BOOST_TEST(
result.first->value().as_int64() == 2);
BEAST_EXPECT(! result.second);
BOOST_TEST(! result.second);
});
}
@ -702,7 +702,7 @@ public:
{
object o({{"a", 1}}, sp);
o.insert_or_assign("a", str_);
BEAST_EXPECT(o["a"].is_string());
BOOST_TEST(o["a"].is_string());
});
fail_loop([&](storage_ptr const& sp)
@ -712,8 +712,8 @@ public:
{"b", 2},
{"c", 3}}, sp);
o.insert_or_assign("d", str_);
BEAST_EXPECT(o["d"].is_string());
BEAST_EXPECT(o.size() == 4);
BOOST_TEST(o["d"].is_string());
BOOST_TEST(o.size() == 4);
});
fail_loop([&](storage_ptr const& sp)
@ -727,9 +727,9 @@ public:
fail_loop([&](storage_ptr const& sp)
{
object o({{"a", 1}}, sp);
BEAST_EXPECT(
BOOST_TEST(
! o.insert_or_assign("a", 2).second);
BEAST_EXPECT(o["a"].as_int64() == 2);
BOOST_TEST(o["a"].as_int64() == 2);
});
}
@ -753,8 +753,8 @@ public:
{"b", true},
{"c", "hello"}}, sp);
auto it = o.erase(o.begin());
BEAST_EXPECT(it->key() == "c");
BEAST_EXPECT(
BOOST_TEST(it->key() == "c");
BOOST_TEST(
it->value().as_string() == "hello");
check(o, 7);
});
@ -767,7 +767,7 @@ public:
{"a", 1},
{"b", true},
{"c", "hello"}});
BEAST_EXPECT(o.erase("b2") == 0);
BOOST_TEST(o.erase("b2") == 0);
check(o, 3);
}
@ -777,7 +777,7 @@ public:
{"b", true},
{"b2", 2},
{"c", "hello"}});
BEAST_EXPECT(o.erase("b2") == 1);
BOOST_TEST(o.erase("b2") == 1);
check(o, 7);
}
}
@ -788,9 +788,9 @@ public:
object o1 = {{"a",1}, {"b",true}, {"c", "hello"}};
object o2 = {{"d",{1,2,3}}};
swap(o1, o2);
BEAST_EXPECT(o1.size() == 1);
BEAST_EXPECT(o2.size() == 3);
BEAST_EXPECT(o1.count("d") == 1);
BOOST_TEST(o1.size() == 1);
BOOST_TEST(o2.size() == 3);
BOOST_TEST(o1.count("d") == 1);
}
fail_loop([&](storage_ptr const& sp)
@ -798,9 +798,9 @@ public:
object o1 = {{"a",1}, {"b",true}, {"c", "hello"}};
object o2({{"d",{1,2,3}}}, sp);
swap(o1, o2);
BEAST_EXPECT(o1.size() == 1);
BEAST_EXPECT(o2.size() == 3);
BEAST_EXPECT(o1.count("d") == 1);
BOOST_TEST(o1.size() == 1);
BOOST_TEST(o2.size() == 3);
BOOST_TEST(o1.count("d") == 1);
});
fail_loop([&](storage_ptr const& sp)
@ -808,9 +808,9 @@ public:
object o1({{"d",{1,2,3}}}, sp);
object o2 = {{"a",1}, {"b",true}, {"c", "hello"}};
swap(o1, o2);
BEAST_EXPECT(o1.size() == 3);
BEAST_EXPECT(o2.size() == 1);
BEAST_EXPECT(o2.count("d") == 1);
BOOST_TEST(o1.size() == 3);
BOOST_TEST(o2.size() == 1);
BOOST_TEST(o2.count("d") == 1);
});
}
}
@ -828,17 +828,17 @@ public:
// at(key)
{
BEAST_EXPECT(
BOOST_TEST(
o1.at("a").is_number());
BEAST_THROWS((o1.at("d")),
BOOST_TEST_THROWS((o1.at("d")),
std::out_of_range);
}
// at(key) const
{
BEAST_EXPECT(
BOOST_TEST(
co1.at("a").is_number());
BEAST_THROWS((co1.at("d")),
BOOST_TEST_THROWS((co1.at("d")),
std::out_of_range);
}
@ -848,31 +848,31 @@ public:
{"a", 1},
{"b", true},
{"c", "hello"}});
BEAST_EXPECT(o.count("d") == 0);;
BEAST_EXPECT(o["a"].is_number());
BEAST_EXPECT(o["d"].is_null());
BEAST_EXPECT(o.count("d") == 1);
BOOST_TEST(o.count("d") == 0);;
BOOST_TEST(o["a"].is_number());
BOOST_TEST(o["d"].is_null());
BOOST_TEST(o.count("d") == 1);
}
// count(key)
{
BEAST_EXPECT(o1.count("a") == 1);
BEAST_EXPECT(o1.count("d") == 0);
BEAST_EXPECT(o1.count("e") == 0);
BOOST_TEST(o1.count("a") == 1);
BOOST_TEST(o1.count("d") == 0);
BOOST_TEST(o1.count("e") == 0);
}
// find(key)
{
BEAST_EXPECT(
BOOST_TEST(
o1.find("a")->key() == "a");
BEAST_EXPECT(
BOOST_TEST(
o1.find("e") == o1.end());
}
// contains(key)
{
BEAST_EXPECT(o1.contains("a"));
BEAST_EXPECT(! o1.contains("e"));
BOOST_TEST(o1.contains("a"));
BOOST_TEST(! o1.contains("e"));
}
}
@ -886,17 +886,17 @@ public:
for(std::size_t i = 0; i < 10; ++i)
o.emplace(std::to_string(i), i);
o.reserve(15);
BEAST_EXPECT(o.capacity() >= 15);
BOOST_TEST(o.capacity() >= 15);
o.reserve(20);
BEAST_EXPECT(o.capacity() >= 20);
BOOST_TEST(o.capacity() >= 20);
}
{
object o;
o.reserve(3);
BEAST_EXPECT(o.capacity() == 3);
BOOST_TEST(o.capacity() == 3);
o.reserve(7);
BEAST_EXPECT(o.capacity() == 7);
BOOST_TEST(o.capacity() == 7);
}
}
}
@ -913,18 +913,18 @@ public:
{"b", true},
{"b", {1,2,3}},
{"c", "hello"}});
BEAST_EXPECT(o.at("a").as_int64() == 1);
BEAST_EXPECT(o.at("b").as_bool());
BEAST_EXPECT(o.at("c").as_string() == "hello");
BOOST_TEST(o.at("a").as_int64() == 1);
BOOST_TEST(o.at("b").as_bool());
BOOST_TEST(o.at("c").as_string() == "hello");
}
// find in missing or empty tables
{
object o;
BEAST_EXPECT(o.find("a") == o.end());
BOOST_TEST(o.find("a") == o.end());
o.reserve(3);
BEAST_EXPECT(o.capacity() > 0);
BEAST_EXPECT(o.find("a") == o.end());
BOOST_TEST(o.capacity() > 0);
BOOST_TEST(o.find("a") == o.end());
}
// destroy key_value_pair array with need_free=false
@ -939,7 +939,7 @@ public:
}
void
run() override
run()
{
testSpecial();
testIterators();
@ -951,7 +951,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,object);
TEST_SUITE(object_test, "boost.json.object");
} // json
} // boost

49
test/parser.cpp
View File

@ -10,20 +10,23 @@
// Test that header file is self-contained.
#include <boost/json/parser.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <boost/json/pool.hpp>
#include <boost/json/serializer.hpp>
#include <sstream>
#include "parse-vectors.hpp"
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class parser_test : public beast::unit_test::suite
class parser_test
{
public:
::test_suite::log_type log;
value
from_string_test(
string_view s,
@ -38,8 +41,7 @@ public:
ec);
if(! ec)
p.finish(ec);
BEAST_EXPECTS(! ec,
ec.message());
BOOST_TEST(! ec);
//log << " " << to_string_test(p.get()) << std::endl;
return p.release();
}
@ -54,7 +56,7 @@ public:
to_string(jv1);
auto jv2 =
from_string_test(s2);
if(! BEAST_EXPECT(equal(jv1, jv2)))
if(! BOOST_TEST(equal(jv1, jv2)))
log <<
" " << s1 << "\n" <<
" " << s2 << std::endl;
@ -186,13 +188,11 @@ public:
parser p;
p.start();
p.write(js.data(), N, ec);
if(BEAST_EXPECTS(! ec,
ec.message()))
if(BOOST_TEST(! ec))
{
p.finish(js.data() + N,
js.size() - N, ec);
if(BEAST_EXPECTS(! ec,
ec.message()))
if(BOOST_TEST(! ec))
check_round_trip(
p.release(), js);
}
@ -246,9 +246,8 @@ public:
parser p;
error_code ec;
p.write("", 0, ec);
BEAST_EXPECTS(
ec == error::need_start,
ec.message());
BOOST_TEST(
ec == error::need_start);
}
// destroy after start
@ -260,7 +259,7 @@ public:
// release before done
{
parser p;
BEAST_THROWS(
BOOST_TEST_THROWS(
p.release(),
std::logic_error);
}
@ -287,14 +286,14 @@ public:
{
error_code ec;
auto jv = parse(js, ec);
BEAST_EXPECTS(! ec, ec.message());
BOOST_TEST(! ec);
check_round_trip(jv, js);
}
{
error_code ec;
auto jv = parse("xxx", ec);
BEAST_EXPECT(ec);
BEAST_EXPECT(jv.is_null());
BOOST_TEST(ec);
BOOST_TEST(jv.is_null());
}
}
@ -304,7 +303,7 @@ public:
error_code ec;
scoped_storage<pool> sp;
auto jv = parse(js, ec, sp);
BEAST_EXPECTS(! ec, ec.message());
BOOST_TEST(! ec);
check_round_trip(jv, js);
}
@ -312,8 +311,8 @@ public:
error_code ec;
scoped_storage<pool> sp;
auto jv = parse("xxx", ec, sp);
BEAST_EXPECT(ec);
BEAST_EXPECT(jv.is_null());
BOOST_TEST(ec);
BOOST_TEST(jv.is_null());
}
}
@ -327,7 +326,7 @@ public:
{
value jv;
BEAST_THROWS(
BOOST_TEST_THROWS(
jv = parse("{,"),
system_error);
}
@ -343,7 +342,7 @@ public:
{
scoped_storage<pool> sp;
value jv;
BEAST_THROWS(
BOOST_TEST_THROWS(
jv = parse("xxx", sp),
system_error);
}
@ -381,9 +380,9 @@ R"xx({
error_code ec;
p.start();
p.finish(in.data(), in.size(), ec);
if(BEAST_EXPECTS(! ec, ec.message()))
if(BOOST_TEST(! ec))
{
BEAST_EXPECT(to_string(p.release()) ==
BOOST_TEST(to_string(p.release()) ==
"{\"glossary\":{\"title\":\"example glossary\",\"GlossDiv\":"
"{\"title\":\"S\",\"GlossList\":{\"GlossEntry\":{\"ID\":\"SGML\","
"\"SortAs\":\"SGML\",\"GlossTerm\":\"Standard Generalized Markup "
@ -399,7 +398,7 @@ R"xx({
void
testIssue15()
{
BEAST_EXPECT(
BOOST_TEST(
json::parse("{\"port\": 12345}")
.as_object()
.at("port")
@ -422,7 +421,7 @@ R"xx({
}
};
BEAST_DEFINE_TESTSUITE(boost,json,parser);
TEST_SUITE(parser_test, "boost.json.parser");
} // json
} // boost

11
test/pool.cpp
View File

@ -11,12 +11,13 @@
#include <boost/json/pool.hpp>
#include <boost/json/parser.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test_suite.hpp"
namespace boost {
namespace json {
class pool_test : public beast::unit_test::suite
class pool_test
{
public:
void
@ -46,17 +47,17 @@ R"xx({
}
})xx"
, make_storage<pool>());
pass();
BOOST_TEST_PASS();
}
void
run() override
run()
{
testStorage();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,pool);
TEST_SUITE(pool_test, "boost.json.pool");
} // json
} // boost

24
test/ryu/gtest.hpp
View File

@ -10,18 +10,24 @@
#ifndef GTEST_HPP
#define GTEST_HPP
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <boost/utility/string_view.hpp>
#define TEST(s1,s2) \
struct s2 ## s1 ## _test; \
BEAST_DEFINE_TESTSUITE(boost,Ryu,s2##s1); \
struct s2 ## s1 ## _test : ::boost::beast::unit_test::suite { \
void run() override; }; void s2##s1##_test::run()
#include "test_suite.hpp"
#define EXPECT_STREQ(s1, s2) BEAST_EXPECT(::boost::string_view(s1) == ::boost::string_view(s2))
#define ASSERT_STREQ(s1, s2) { auto const s1_ = (s1); auto const s2_ = (s2); \
#define TEST(s1,s2) \
struct s1 ## _ ## s2 ## _test; \
TEST_SUITE(s1 ## _ ## s2 ## _test, "boost.Ryu." #s1 "." #s2); \
struct s1 ## _ ## s2 ## _test { \
void run(); }; void s1 ## _ ## s2 ## _test::run()
#define EXPECT_STREQ(s1, s2) \
BOOST_TEST(::boost::json::string_view(s1) == \
::boost::json::string_view(s2))
#define ASSERT_STREQ(s1, s2) \
{ auto const s1_ = (s1); auto const s2_ = (s2); \
EXPECT_STREQ(s1_, s2_); }
#define ASSERT_EQ(e1, e2) BEAST_EXPECT((e1)==(e2))
#define ASSERT_EQ(e1, e2) BOOST_TEST((e1)==(e2))
#endif

37
test/serializer.cpp
View File

@ -11,17 +11,20 @@
#include <boost/json/serializer.hpp>
#include <boost/json/parser.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <iostream>
#include "parse-vectors.hpp"
#include "test.hpp"
#include <iostream>
#include "test_suite.hpp"
namespace boost {
namespace json {
class serializer_test : public beast::unit_test::suite
class serializer_test
{
public:
::test_suite::log_type log;
void
grind_one(
string_view s,
@ -32,7 +35,7 @@ public:
error_code ec;
auto const s1 = to_string(jv);
auto const jv2 = parse(s1, ec);
if(! BEAST_EXPECT(equal(jv, jv2)))
if(! BOOST_TEST(equal(jv, jv2)))
{
if(name.empty())
log <<
@ -58,7 +61,7 @@ public:
auto const s1 = to_string(jv);
auto const jv2 = parse(s1, ec);
BEAST_EXPECT(equal(jv, jv2));
BOOST_TEST(equal(jv, jv2));
}
}
@ -94,7 +97,7 @@ public:
" " << s1 << "\n"
" " << s2 << std::endl;
};
if(! BEAST_EXPECT(
if(! BOOST_TEST(
s2.size() == i))
{
dump();
@ -103,13 +106,13 @@ public:
s2.grow(sr.read(
s2.data() + i,
s1.size() - i));
if(! BEAST_EXPECT(
if(! BOOST_TEST(
s2.size() == s1.size()))
{
dump();
break;
}
if(! BEAST_EXPECT(s2 == s1))
if(! BOOST_TEST(s2 == s1))
{
dump();
break;
@ -135,7 +138,7 @@ public:
// is_done()
{
serializer sr(jv);
BEAST_EXPECT(! sr.is_done());
BOOST_TEST(! sr.is_done());
}
// read()
@ -145,15 +148,15 @@ public:
char buf[1024];
auto n = sr.read(
buf, sizeof(buf));
BEAST_EXPECT(sr.is_done());
BEAST_EXPECT(string_view(
BOOST_TEST(sr.is_done());
BOOST_TEST(string_view(
buf, n) == "null");
}
{
char buf[32];
serializer sr;
BEAST_THROWS(
BOOST_TEST_THROWS(
sr.read(buf, sizeof(buf)),
std::logic_error);
}
@ -443,15 +446,13 @@ public:
{
error_code ec;
auto const jv1 = parse(js, ec);
if(! BEAST_EXPECTS(! ec,
ec.message()))
if(! BOOST_TEST(! ec))
return;
auto const jv2 =
parse(to_ostream(jv1), ec);
if(! BEAST_EXPECTS(! ec,
ec.message()))
if(! BOOST_TEST(! ec))
return;
if(! BEAST_EXPECT(equal(jv1, jv2)))
if(! BOOST_TEST(equal(jv1, jv2)))
log <<
" " << js << "\n"
" " << jv1 << "\n"
@ -474,7 +475,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,serializer);
TEST_SUITE(serializer_test, "boost.json.serializer");
} // json
} // boost

11
test/snippets.cpp
View File

@ -9,10 +9,11 @@
#include <boost/json.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <complex>
#include <iostream>
#include "test_suite.hpp"
namespace boost {
namespace json {
@ -477,11 +478,11 @@ usingExchange2()
//----------------------------------------------------------
class snippets_test : public beast::unit_test::suite
class snippets_test
{
public:
void
run() override
run()
{
(void)&usingStrings;
(void)&usingArrays;
@ -494,11 +495,11 @@ public:
(void)&usingSerializing;
(void)&usingExchange1;
(void)&usingExchange2;
pass();
BOOST_TEST_PASS();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,snippets);
TEST_SUITE(snippets_test, "boost.json.snippets");
} // json
} // boost

29
test/storage_ptr.cpp
View File

@ -10,14 +10,13 @@
// Test that header file is self-contained.
#include <boost/json/storage_ptr.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class storage_ptr_test : public beast::unit_test::suite
class storage_ptr_test
{
public:
struct not_storage
@ -91,22 +90,22 @@ public:
// storage_ptr()
{
storage_ptr sp;
BEAST_EXPECT(sp.get());
BOOST_TEST(sp.get());
}
// storage_ptr(storage_ptr&&)
{
storage_ptr sp1 = dsp;
storage_ptr sp2(std::move(sp1));
BEAST_EXPECT(sp1.get());
BEAST_EXPECT(*sp2 == *dsp);
BOOST_TEST(sp1.get());
BOOST_TEST(*sp2 == *dsp);
}
// storage_ptr(storage_ptr const&)
{
storage_ptr sp1 = dsp;
storage_ptr sp2(sp1);
BEAST_EXPECT(sp1 == sp2);
BOOST_TEST(sp1 == sp2);
}
// operator=(storage_ptr&&)
@ -114,7 +113,7 @@ public:
storage_ptr sp1(dsp);
storage_ptr sp2(usp);
sp2 = std::move(sp1);
BEAST_EXPECT(*sp2 == *dsp);
BOOST_TEST(*sp2 == *dsp);
}
// operator=(storage_ptr const&)
@ -122,43 +121,43 @@ public:
storage_ptr sp1(dsp);
storage_ptr sp2(usp);
sp2 = sp1;
BEAST_EXPECT(*sp1 == *sp2);
BOOST_TEST(*sp1 == *sp2);
}
// get()
{
storage_ptr sp(dsp);
BEAST_EXPECT(sp.get() == dsp.get());
BOOST_TEST(sp.get() == dsp.get());
}
// operator->()
{
storage_ptr sp(dsp);
BEAST_EXPECT(sp.operator->() == dsp.get());
BOOST_TEST(sp.operator->() == dsp.get());
}
// operator*()
{
storage_ptr sp(dsp);
BEAST_EXPECT(&sp.operator*() == dsp.get());
BOOST_TEST(&sp.operator*() == dsp.get());
}
// exception in make_storage
{
BEAST_THROWS(
BOOST_TEST_THROWS(
make_storage<throwing>(),
std::exception);
}
}
void
run() override
run()
{
testMembers();
}
};
BEAST_DEFINE_TESTSUITE(boost,json,storage_ptr);
TEST_SUITE(storage_ptr_test, "boost.json.storage_ptr");
} // json
} // boost

1056
test/string.cpp
View File

File diff suppressed because it is too large Load Diff

16
test/test.hpp
View File

@ -15,12 +15,14 @@
#include <boost/json/serializer.hpp>
#include <boost/json/storage_ptr.hpp>
#include <boost/json/detail/format.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include <cstddef>
#include <iterator>
#include <memory>
#include <type_traits>
#include "test_suite.hpp"
namespace boost {
namespace json {
@ -54,7 +56,7 @@ struct fail_storage
~fail_storage()
{
BEAST_EXPECT(nalloc == 0);
BOOST_TEST(nalloc == 0);
}
void*
@ -79,7 +81,7 @@ struct fail_storage
std::size_t,
std::size_t) noexcept
{
if(BEAST_EXPECT(nalloc > 0))
if(BOOST_TEST(nalloc > 0))
--nalloc;
::operator delete(p);
}
@ -103,7 +105,7 @@ fail_loop(F&& f)
}
break;
}
BEAST_EXPECT(ss->fail < 200);
BOOST_TEST(ss->fail < 200);
}
//----------------------------------------------------------
@ -577,7 +579,7 @@ check_storage(
object const& o,
storage_ptr const& sp)
{
BEAST_EXPECT(equal_storage(o, sp));
BOOST_TEST(equal_storage(o, sp));
}
inline
@ -586,7 +588,7 @@ check_storage(
array const& a,
storage_ptr const& sp)
{
BEAST_EXPECT(equal_storage(a, sp));
BOOST_TEST(equal_storage(a, sp));
}
inline
@ -595,7 +597,7 @@ check_storage(
value const& v,
storage_ptr const& sp)
{
BEAST_EXPECT(equal_storage(v, sp));
BOOST_TEST(equal_storage(v, sp));
}
//----------------------------------------------------------

641
test/test_suite.hpp Normal file
View File

@ -0,0 +1,641 @@
//
// Copyright (c) 2019 Vinnie Falco (vinnie.falco@gmail.com)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
// Official repository: https://github.com/vinniefalco/json
//
#ifndef TEST_SUITE_HPP
#define TEST_SUITE_HPP
#include <algorithm>
#include <atomic>
#include <chrono>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <ios>
#include <memory>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <vector>
#ifdef _MSC_VER
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <debugapi.h>
#endif
// This is a derivative work
// Copyright 2002-2018 Peter Dimov
// Copyright (c) 2002, 2009, 2014 Peter Dimov
// Copyright (2) Beman Dawes 2010, 2011
// Copyright (3) Ion Gaztanaga 2013
//
// Copyright 2018 Glen Joseph Fernandes
// (glenjofe@gmail.com)
namespace test_suite {
//----------------------------------------------------------
#ifdef _MSC_VER
namespace detail {
template<
class CharT, class Traits, class Allocator>
class debug_streambuf
: public std::basic_stringbuf<
CharT, Traits, Allocator>
{
using ostream =
std::basic_ostream<CharT, Traits>;
ostream& os_;
bool dbg_;
template<class T>
void write(T const*) = delete;
void write(char const* s)
{
if(dbg_)
::OutputDebugStringA(s);
os_ << s;
}
void write(wchar_t const* s)
{
if(dbg_)
::OutputDebugStringW(s);
os_ << s;
}
public:
explicit
debug_streambuf(ostream& os)
: os_(os)
, dbg_(::IsDebuggerPresent() != 0)
{
}
~debug_streambuf()
{
sync();
}
int
sync() override
{
write(this->str().c_str());
this->str("");
return 0;
}
};
/** std::ostream with Visual Studio IDE redirection.
Instances of this stream wrap a specified `std::ostream`
(such as `std::cout` or `std::cerr`). If the IDE debugger
is attached when the stream is created, output will be
additionally copied to the Visual Studio Output window.
*/
template<
class CharT,
class Traits = std::char_traits<CharT>,
class Allocator = std::allocator<CharT>
>
class basic_debug_stream
: public std::basic_ostream<CharT, Traits>
{
detail::debug_streambuf<
CharT, Traits, Allocator> buf_;
public:
/** Construct a stream.
@param os The output stream to wrap.
*/
explicit
basic_debug_stream(std::ostream& os)
: std::basic_ostream<CharT, Traits>(&buf_)
, buf_(os)
{
if(os.flags() & std::ios::unitbuf)
std::unitbuf(*this);
}
};
} // detail
using debug_stream = detail::basic_debug_stream<char>;
using debug_wstream = detail::basic_debug_stream<wchar_t>;
#else
using debug_stream = std::ostream&;
using debug_wstream = std::wostream&;
#endif
//----------------------------------------------------------
namespace detail {
struct suite_info
{
char const* name;
void (*run)();
};
class runner;
inline
runner*&
current() noexcept;
class runner
{
runner* saved_;
public:
runner() noexcept
: saved_(current())
{
current() = this;
}
virtual
~runner()
{
current() = saved_;
}
virtual void on_begin(char const* name) = 0;
virtual void on_end() = 0;
virtual void note(char const* msg) = 0;
virtual void pass(char const* expr, char const* file, int line, char const* func) = 0;
virtual void fail(char const* expr, char const* file, int line, char const* func) = 0;
template<class Bool
#if 0
,class = typename std::enable_if<
std::is_convertible<bool, Bool>::Value>::type
#endif
>
bool
maybe_fail(
Bool cond,
char const* expr,
char const* file,
int line,
char const* func)
{
if(static_cast<bool>(cond))
{
pass(expr, file, line, func);
return true;
}
fail(expr, file, line, func);
return false;
}
void
run(suite_info const& si)
{
on_begin(si.name);
si.run();
on_end();
}
};
runner*&
current() noexcept
{
static runner* p = nullptr;
return p;
}
//----------------------------------------------------------
using clock_type =
std::chrono::steady_clock;
struct elapsed
{
clock_type::duration d;
};
inline
std::ostream&
operator<<(
std::ostream& os,
elapsed const& e)
{
using namespace std::chrono;
auto const ms = duration_cast<
milliseconds>(e.d);
if(ms < seconds{1})
{
os << ms.count() << "ms";
}
else
{
std::streamsize width{
os.width()};
std::streamsize precision{
os.precision()};
os << std::fixed <<
std::setprecision(1) <<
(ms.count() / 1000.0) << "s";
os.precision(precision);
os.width(width);
}
return os;
}
class simple_runner : public runner
{
struct summary
{
char const* name;
clock_type::time_point start;
clock_type::duration elapsed;
std::atomic<std::size_t> failed;
std::atomic<std::size_t> total;
summary(summary const& other) noexcept
: name(other.name)
, start(other.start)
, elapsed(other.elapsed)
, failed(other.failed.load())
, total(other.total.load())
{
}
explicit
summary(char const* name_) noexcept
: name(name_)
, start(clock_type::now())
, failed(0)
, total(0)
{
}
};
summary all_;
std::ostream& log_;
std::vector<summary> v_;
public:
explicit
simple_runner(
std::ostream& log)
: all_("(all)")
, log_(log)
{
std::unitbuf(log_);
v_.reserve(256);
}
~simple_runner()
{
log_ <<
elapsed{clock_type::now() -
all_.start } << ", " <<
v_.size() << " suites, " <<
all_.failed.load() << " failures, " <<
all_.total.load() << " total." <<
std::endl;
}
// true if no failures
bool
success() const noexcept
{
return all_.failed.load() == 0;
}
void
on_begin(char const* name) override
{
v_.emplace_back(name);
log_ << name << "\n";
}
void
on_end() override
{
v_.back().elapsed =
clock_type::now() -
v_.back().start;
}
void
note(char const* msg) override
{
log_ << msg << "\n";
}
void
pass(char const*, char const*, int, char const*) override
{
++all_.total;
++v_.back().total;
}
void
fail(char const* expr, char const* file, int line, char const* func) override
{
++all_.failed;
++v_.back().total;
++v_.back().failed;
auto const id = ++all_.total;
log_ <<
"#" << id <<
" failed: " << expr <<
", file: " << file <<
"(" << line << ") " <<
func << "\n";
}
};
//----------------------------------------------------------
template<
class CharT,
class Traits = std::char_traits<CharT>,
class Allocator = std::allocator<CharT>
>
class log_ostream
: public std::basic_ostream<CharT, Traits>
{
struct buffer_type :
std::basic_stringbuf<
CharT, Traits, Allocator>
{
~buffer_type()
{
sync();
}
int
sync() override
{
auto const& s = this->str();
if(s.size() > 0)
current()->note(s.c_str());
this->str("");
return 0;
}
};
buffer_type buf_;
public:
log_ostream()
: std::basic_ostream<
CharT, Traits>(&buf_)
{
}
};
//----------------------------------------------------------
class suite_list
{
static std::size_t const max_size_ = 256;
std::size_t count_ = 0;
suite_info data_[max_size_];
public:
void
insert(suite_info inf)
{
#ifndef BOOST_NO_EXCEPTIONS
if(count_ == max_size_)
throw std::length_error(
"too many test suites");
#endif
data_[count_++] = inf;
}
suite_info const*
begin() const noexcept
{
return data_;
}
suite_info const*
end() const noexcept
{
return begin() + count_;
}
void
sort()
{
std::sort(
data_,
data_ + count_,
[]( detail::suite_info const& lhs,
detail::suite_info const& rhs)
{
return std::lexicographical_compare(
lhs.name, lhs.name + std::strlen(lhs.name),
rhs.name, rhs.name + std::strlen(rhs.name));
});
}
};
inline
suite_list&
suites()
{
static suite_list list;
return list;
}
//----------------------------------------------------------
template<class T>
struct instance
{
explicit
instance(
char const* name) noexcept
{
suites().insert(suite_info{
name, &instance::run });
}
static
void
run()
{
auto const saved =
current();
//current()->os_
T().run();
current() = saved;
}
};
//----------------------------------------------------------
inline
void
current_function_helper()
{
#if defined(__GNUC__) || \
(defined(__MWERKS__) && (__MWERKS__ >= 0x3000)) || \
(defined(__ICC) && (__ICC >= 600)) || \
defined(__ghs__) || \
defined(__clang__)
# define TEST_SUITE_FUNCTION __PRETTY_FUNCTION__
#elif defined(__DMC__) && (__DMC__ >= 0x810)
# define TEST_SUITE_FUNCTION __PRETTY_FUNCTION__
#elif defined(__FUNCSIG__)
# define TEST_SUITE_FUNCTION __FUNCSIG__
#elif (defined(__INTEL_COMPILER) && (__INTEL_COMPILER >= 600)) || \
(defined(__IBMCPP__) && (__IBMCPP__ >= 500))
# define TEST_SUITE_FUNCTION __FUNCTION__
#elif defined(__BORLANDC__) && (__BORLANDC__ >= 0x550)
# define TEST_SUITE_FUNCTION __FUNC__
#elif defined(__STDC_VERSION__) && (__STDC_VERSION__ >= 199901)
# define TEST_SUITE_FUNCTION __func__
#elif defined(__cplusplus) && (__cplusplus >= 201103)
# define TEST_SUITE_FUNCTION __func__
#else
# define TEST_SUITE_FUNCTION "(unknown)"
#endif
}
} // detail
//----------------------------------------------------------
/** The type of log for output to the currently running suite.
*/
using log_type = detail::log_ostream<char>;
#define BOOST_TEST(expr) \
::test_suite::detail::current()->maybe_fail( \
(expr), #expr, __FILE__, __LINE__, TEST_SUITE_FUNCTION)
#define BOOST_ERROR(msg) \
::test_suite::detail::current()->fail( \
msg, __FILE__, __LINE__, TEST_SUITE_FUNCTION)
#define BOOST_TEST_PASS() \
::test_suite::detail::current()->pass( \
"", __FILE__, __LINE__, TEST_SUITE_FUNCTION)
#define BOOST_TEST_FAIL() \
::test_suite::detail::current()->fail( \
"", __FILE__, __LINE__, TEST_SUITE_FUNCTION)
#define BOOST_TEST_NOT(expr) BOOST_TEST(!(expr))
#ifndef BOOST_NO_EXCEPTIONS
# define BOOST_TEST_THROWS( expr, except ) \
try { \
expr; \
::test_suite::detail::current()->fail ( \
#except, __FILE__, __LINE__, \
TEST_SUITE_FUNCTION); \
} \
catch(except const&) { \
::test_suite::detail::current()->pass( \
#except, __FILE__, __LINE__, \
TEST_SUITE_FUNCTION); \
} \
catch(...) { \
::test_suite::detail::current()->fail( \
#except, __FILE__, __LINE__, \
TEST_SUITE_FUNCTION); \
}
#else
#define BOOST_TEST_THROWS( expr, except )
#endif
#define TEST_SUITE(type, name) \
namespace { static ::test_suite::detail::instance<type> type##_(name); }
inline
int
run(std::ostream& log,
int argc, char const* const* argv)
{
if(argc == 2)
{
std::string arg(argv[1]);
if(arg == "-h" || arg == "--help")
{
log <<
"Usage:\n"
" " << argv[0] << ": { <suite-name>... }" <<
std::endl;
return EXIT_SUCCESS;
}
}
using namespace ::test_suite;
detail::simple_runner runner(log);
detail::suites().sort();
if(argc == 1)
{
for(auto const& e : detail::suites())
runner.run(e);
}
else
{
std::vector<std::string> args;
args.reserve(argc - 1);
for(int i = 0; i < argc - 1; ++i)
args.push_back(argv[i + 1]);
for(auto const& e : detail::suites())
{
std::string s(e.name);
if(std::find_if(
args.begin(), args.end(),
[&](std::string const& arg)
{
if(arg.size() > s.size())
return false;
return s.compare(
s.size() - arg.size(),
arg.size(),
arg.data(),
arg.size()) == 0;
}) != args.end())
{
runner.run(e);
}
}
}
return runner.success() ?
EXIT_SUCCESS : EXIT_FAILURE;
}
} // test_suite
#endif

1036
test/value.cpp
View File

File diff suppressed because it is too large Load Diff

14
test/value_ref.cpp
View File

@ -13,14 +13,12 @@
#include <boost/json/value.hpp>
#include <boost/json/serializer.hpp>
#include <boost/beast/_experimental/unit_test/suite.hpp>
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class value_ref_test : public beast::unit_test::suite
class value_ref_test
{
public:
using init_list =
@ -177,7 +175,7 @@ public:
auto const jv =
value_ref(init).make_value({});
auto const js = to_string(jv);
BEAST_EXPECT(js == s);
BOOST_TEST(js == s);
}
void
@ -276,7 +274,7 @@ public:
{
auto const jv = value(object(init));
auto const js = to_string(jv);
BEAST_EXPECT(js == s);
BOOST_TEST(js == s);
}
void
@ -297,7 +295,7 @@ public:
}
void
run() override
run()
{
testCtors();
testInitList();
@ -306,7 +304,7 @@ public:
}
};
BEAST_DEFINE_TESTSUITE(boost,json,value_ref);
TEST_SUITE(value_ref_test, "boost.json.value_ref");
} // json
} // boost