boost_mirror/json
1
0
Fork 0
mirror of https://github.com/boostorg/json.git synced 2025-05-11 21:53:58 +00:00
Code Issues Packages Projects Releases Wiki Activity
json/test/string.cpp
Vinnie Falco 07246e2909 Add standalone test_suite
2019-12-11 18:34:39 -08:00

2626 lines
72 KiB
C++
Raw Blame History

//
// 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/BeastLounge
//
// Test that header file is self-contained.
#include <boost/json/string.hpp>
#include <numeric>
#include <sstream>
#include <string>
#include <stdint.h>
#include "test.hpp"
#include "test_suite.hpp"
namespace boost {
namespace json {
class string_test
{
public:
#if BOOST_JSON_ARCH == 64
# define INIT1 { 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n' }
# define INIT2 { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O' }
#elif BOOST_JSON_ARCH == 32
# define INIT1 { 'a', 'b', 'c', 'd', 'e', 'f' }
# define INIT2 { 'A', 'B', 'C', 'D', 'E', 'F', 'G' }
#else
# error Unknown architecture
#endif
struct test_vectors
{
// fit in sbo
string_view v1; // "abc...
// dynamic alloc
string_view v2; // "ABC...
std::string const s1;
std::string const s2;
test_vectors()
: s1([&]
{
std::string s;
s.resize(string{}.capacity());
std::iota(s.begin(), s.end(), 'a');
return s;
}())
, s2([&]
{
std::string s;
s.resize(string{}.capacity() + 1);
std::iota(s.begin(), s.end(), 'A');
return s;
}())
{
v1 = s1;
v2 = s2;
BOOST_TEST(std::string(INIT1) == s1);
BOOST_TEST(std::string(INIT2) == s2);
}
};
static
string_view
last_of(
string_view s,
std::size_t n)
{
return s.substr(s.size() - n);
}
void
testConstruction()
{
test_vectors const t;
// string()
{
string s;
}
// string(storage_ptr)
{
auto const sp =
make_storage<unique_storage>();
string s(sp);
BOOST_TEST(s.empty());
BOOST_TEST(*s.storage() == *sp.get());
}
// string(size_type, char, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
BOOST_TEST(s == std::string(t.v1.size(), '*'));
});
{
string s(t.v2.size(), '*');
BOOST_TEST(s == std::string(t.v2.size(), '*'));
}
}
// string(string const&, size_type, size_type, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(string(t.v1), 1, 3, sp);
BOOST_TEST(s == "bcd");
});
{
string s(string(t.v1), 1, 3);
BOOST_TEST(s.size() == 3);
BOOST_TEST(s == "bcd");
}
{
string s(string(t.v1), 1);
BOOST_TEST(s == t.v1.substr(1));
}
}
// string(char const*, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.s1.c_str(), sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.s2.c_str(), sp);
BOOST_TEST(s == t.v2);
});
{
string s(t.s1.c_str());
BOOST_TEST(s == t.v1);
}
{
string s(t.s2.c_str());
BOOST_TEST(s == t.v2);
}
}
// string(char const*, size_type, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.s1.c_str(), 3, sp);
BOOST_TEST(s == "abc");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.s2.c_str(), 3, sp);
BOOST_TEST(s == "ABC");
});
{
string s(t.s1.c_str(), 3);
BOOST_TEST(s == "abc");
}
{
string s(t.s2.c_str(), 3);
BOOST_TEST(s == "ABC");
}
}
// string(InputIt, InputIt, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.begin(), t.v1.end(), sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.begin(), t.v2.end(), sp);
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(
make_input_iterator(t.v1.begin()),
make_input_iterator(t.v1.end()), sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(
make_input_iterator(t.v2.begin()),
make_input_iterator(t.v2.end()), sp);
BOOST_TEST(s == t.v2);
});
{
string s(t.v1.begin(), t.v1.end());
BOOST_TEST(s == t.v1);
}
{
string s(t.v2.begin(), t.v2.end());
BOOST_TEST(s == t.v2);
}
{
string s(
make_input_iterator(t.v1.begin()),
make_input_iterator(t.v1.end()));
BOOST_TEST(s == t.v1);
}
{
string s(
make_input_iterator(t.v2.begin()),
make_input_iterator(t.v2.end()));
BOOST_TEST(s == t.v2);
}
}
// string(string)
{
{
string const s0(t.v1);
string s(s0);
BOOST_TEST(s == t.v1);
}
{
string const s0(t.v2);
string s(s0);
BOOST_TEST(s == t.v2);
}
}
// string(string, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string const s0(t.v1);
string s(s0, sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string const s0(t.v2);
string s(s0, sp);
BOOST_TEST(s == t.v2);
});
}
// string(pilfered<string>)
{
{
string s1(t.v1);
string s2(pilfer(s1));
BOOST_TEST(s2 == t.v1);
BOOST_TEST(s1.empty());
BOOST_TEST(
s1.storage() == nullptr);
}
{
string s1(t.v2);
string s2(pilfer(s1));
BOOST_TEST(s2 == t.v2);
BOOST_TEST(s1.empty());
BOOST_TEST(
s1.storage() == nullptr);
}
}
// string(string&&)
{
{
string s1(t.v1);
string s2(std::move(s1));
BOOST_TEST(s2 == t.v1);
BOOST_TEST(s1.empty());
BOOST_TEST(
*s1.storage() ==
*s2.storage());
}
{
string s1(t.v2);
string s2(std::move(s1));
BOOST_TEST(s2 == t.v2);
BOOST_TEST(s1.empty());
BOOST_TEST(
*s1.storage() ==
*s2.storage());
}
}
// string(string&&, storage_ptr)
{
// same storage
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v1, sp);
string s2(std::move(s1), sp);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(s1.empty());
BOOST_TEST(
*s1.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v2, sp);
string s2(std::move(s1));
BOOST_TEST(s2 == t.v2);
BOOST_TEST(s1.empty());
BOOST_TEST(
*s1.storage() ==
*s2.storage());
});
// different storage
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v1);
string s2(std::move(s1), sp);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(s1 == t.v1);
BOOST_TEST(
*s1.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v2);
string s2(std::move(s1), sp);
BOOST_TEST(s2 == t.v2);
BOOST_TEST(s1 == t.v2);
BOOST_TEST(
*s1.storage() !=
*s2.storage());
});
}
// string(initializer_list, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(INIT1, sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(INIT2, sp);
BOOST_TEST(s == t.v2);
});
{
string s(INIT1);
BOOST_TEST(s == t.v1);
}
{
string s(INIT2);
BOOST_TEST(s == t.v2);
}
}
// string(string_view, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
BOOST_TEST(s == t.v2);
});
{
string s(t.v1);
BOOST_TEST(s == t.v1);
}
{
string s(t.v2);
BOOST_TEST(s == t.v2);
}
}
// string(string_view, size_type, size_type, storage_ptr)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, 1, 3, sp);
BOOST_TEST(s == "bcd");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, 1, 3, sp);
BOOST_TEST(s == "BCD");
});
{
string s(t.v1, 1, 3);
BOOST_TEST(s == "bcd");
}
{
string s(t.v2, 1, 3);
BOOST_TEST(s == "BCD");
}
}
}
void
testAssignment()
{
test_vectors const t;
// operator=(string)
{
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string const s2(t.v1);
s = s2;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string const s2(t.v1);
s = s2;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string const s2(t.v2);
s = s2;
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string const s2(t.v2);
s = s2;
BOOST_TEST(s == t.v2);
});
}
// operator=(string&&)
{
// same storage
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v1, sp);
s = std::move(s2);
BOOST_TEST(s == t.v1);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v1, sp);
s = std::move(s2);
BOOST_TEST(s == t.v1);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v2, sp);
s = std::move(s2);
BOOST_TEST(s == t.v2);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v2, sp);
s = std::move(s2);
BOOST_TEST(s == t.v2);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
// different storage
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v1);
s = std::move(s2);
BOOST_TEST(s == t.v1);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v1);
s = std::move(s2);
BOOST_TEST(s == t.v1);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v2);
s = std::move(s2);
BOOST_TEST(s == t.v2);
BOOST_TEST(s2 == t.v2);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v2);
s = std::move(s2);
BOOST_TEST(s == t.v2);
BOOST_TEST(s2 == t.v2);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
}
// operator=(char const*)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s = t.s1.c_str();
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s = t.s1.c_str();
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s = t.s2.c_str();
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s = t.s2.c_str();
BOOST_TEST(s == t.v2);
});
}
// operator=(std::initializer_list<char>)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s = INIT1;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s = INIT2;
BOOST_TEST(s == t.v2);
});
}
// operator=(string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s = t.v1;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s = t.v1;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s = t.v2;
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s = t.v2;
BOOST_TEST(s == t.v2);
});
}
}
void
testAssign()
{
test_vectors const t;
// assign(size_type, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), 'x', sp);
s.assign(t.v1.size(), '*');
BOOST_TEST(
s == std::string(t.v1.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), 'x', sp);
s.assign(t.v1.size(), '*');
BOOST_TEST(
s == std::string(t.v1.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), 'x', sp);
s.assign(t.v2.size(), '*');
BOOST_TEST(
s == std::string(t.v2.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), 'x', sp);
s.assign(t.v2.size(), '*');
BOOST_TEST(
s == std::string(t.v2.size(), '*'));
});
}
// assign(string)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), 'x', sp);
s.assign(string(t.v1.size(), '*'));
BOOST_TEST(
s == std::string(t.v1.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), 'x', sp);
s.assign(string(t.v1.size(), '*'));
BOOST_TEST(
s == std::string(t.v1.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), 'x', sp);
s.assign(string(t.v2.size(), '*'));
BOOST_TEST(
s == std::string(t.v2.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), 'x', sp);
s.assign(string(t.v2.size(), '*'));
BOOST_TEST(
s == std::string(t.v2.size(), '*'));
});
// self-assign
{
string s(t.v1);
s = static_cast<string const&>(s);
BOOST_TEST(s == t.v1);
}
}
// assign(string, size_type, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), 'x', sp);
s.assign(string(t.v1.size(), '*'), 1, 3);
BOOST_TEST(
s == std::string(3, '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), 'x', sp);
s.assign(string(t.v1.size(), '*'), 1, 3);
BOOST_TEST(
s == std::string(3, '*'));
});
}
// assign(string&&)
{
// same storage
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v1, sp);
s.assign(std::move(s2));
BOOST_TEST(s == t.v1);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v1, sp);
s.assign(std::move(s2));
BOOST_TEST(s == t.v1);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v2, sp);
s.assign(std::move(s2));
BOOST_TEST(s == t.v2);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v2, sp);
s.assign(std::move(s2));
BOOST_TEST(s == t.v2);
BOOST_TEST(s2.empty());
BOOST_TEST(
*s.storage() ==
*s2.storage());
});
// different storage
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v1);
s.assign(std::move(s2));
BOOST_TEST(s == t.v1);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v1);
s.assign(std::move(s2));
BOOST_TEST(s == t.v1);
BOOST_TEST(s2 == t.v1);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v1.size(), '*');
string s(c, sp);
string s2(t.v2);
s.assign(std::move(s2));
BOOST_TEST(s == t.v2);
BOOST_TEST(s2 == t.v2);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
fail_loop([&](storage_ptr const& sp)
{
std::string c(t.v2.size(), '*');
string s(c, sp);
string s2(t.v2);
s.assign(std::move(s2));
BOOST_TEST(s == t.v2);
BOOST_TEST(s2 == t.v2);
BOOST_TEST(
*s.storage() !=
*s2.storage());
});
}
// assign(char const*, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s1.c_str(), 3);
BOOST_TEST(s == "abc");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s1.c_str(), 3);
BOOST_TEST(s == "abc");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s2.c_str(), 3);
BOOST_TEST(s == "ABC");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s2.c_str(), 3);
BOOST_TEST(s == "ABC");
});
};
// assign(char const* s)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s1.c_str());
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s1.c_str());
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s2.c_str());
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s2.c_str());
BOOST_TEST(s == t.v2);
});
}
// assign(InputIt, InputIt)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s1.begin(), t.s1.end());
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s1.begin(), t.s1.end());
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(
make_input_iterator(t.s1.begin()),
make_input_iterator(t.s1.end()));
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(
make_input_iterator(t.s1.begin()),
make_input_iterator(t.s1.end()));
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.s2.begin(), t.s2.end());
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.s2.begin(), t.s2.end());
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(
make_input_iterator(t.s2.begin()),
make_input_iterator(t.s2.end()));
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(
make_input_iterator(t.s2.begin()),
make_input_iterator(t.s2.end()));
BOOST_TEST(s == t.v2);
});
// empty range
{
string s(t.v1);
s.assign(t.s1.begin(), t.s1.begin());
BOOST_TEST(s.empty());
}
// empty range
{
string s(t.v1);
s.assign(
make_input_iterator(t.s1.begin()),
make_input_iterator(t.s1.begin()));
BOOST_TEST(s.empty());
}
}
// assign(std::initializer_list<char>)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(INIT1);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(INIT1);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(INIT2);
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(INIT2);
BOOST_TEST(s == t.v2);
});
}
// assign(string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.v1);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.v1);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.v2);
BOOST_TEST(s == t.v2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.v2);
BOOST_TEST(s == t.v2);
});
}
// assign(string_view, size_type, size_type);
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1.size(), '*', sp);
s.assign(t.v1, 1, 3);
BOOST_TEST(s == "bcd");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2.size(), '*', sp);
s.assign(t.v2, 1, 3);
BOOST_TEST(s == "BCD");
});
}
}
void
testElementAccess()
{
test_vectors const t;
string s1(t.v1);
string s2(t.v2);
auto const& cs1(s1);
auto const& cs2(s2);
// at(size_type)
{
BOOST_TEST(s1.at(1) == 'b');
s1.at(1) = '*';
BOOST_TEST(s1.at(1) == '*');
s1.at(1) = 'b';
BOOST_TEST(s1.at(1) == 'b');
BOOST_TEST(s2.at(1) == 'B');
s2.at(1) = '*';
BOOST_TEST(s2.at(1) == '*');
s2.at(1) = 'B';
BOOST_TEST(s2.at(1) == 'B');
BOOST_TEST_THROWS(s1.at(s2.size()),
std::out_of_range);
}
// at(size_type) const
{
BOOST_TEST(cs1.at(1) == 'b');
BOOST_TEST(cs2.at(1) == 'B');
BOOST_TEST_THROWS(cs1.at(cs2.size()),
std::out_of_range);
}
// operator[&](size_type)
{
BOOST_TEST(s1[1] == 'b');
s1[1] = '*';
BOOST_TEST(s1[1] == '*');
s1[1] = 'b';
BOOST_TEST(s1[1] == 'b');
BOOST_TEST(s2[1] == 'B');
s2[1] = '*';
BOOST_TEST(s2[1] == '*');
s2[1] = 'B';
BOOST_TEST(s2[1] == 'B');
}
// operator[&](size_type) const
{
BOOST_TEST(cs1[1] == 'b');
BOOST_TEST(cs2[1] == 'B');
}
// front()
{
BOOST_TEST(s1.front() == 'a');
s1.front() = '*';
BOOST_TEST(s1.front() == '*');
s1.front() = 'a';
BOOST_TEST(s1.front() == 'a');
BOOST_TEST(s2.front() == 'A');
s2.front() = '*';
BOOST_TEST(s2.front() == '*');
s2.front() = 'A';
BOOST_TEST(s2.front() == 'A');
}
// front() const
{
BOOST_TEST(cs1.front() == 'a');
BOOST_TEST(cs2.front() == 'A');
}
// back()
{
auto const ch1 = s1.at(s1.size()-1);
auto const ch2 = s2.at(s2.size()-1);
BOOST_TEST(s1.back() == ch1);
s1.back() = '*';
BOOST_TEST(s1.back() == '*');
s1.back() = ch1;
BOOST_TEST(s1.back() == ch1);
BOOST_TEST(s2.back() == ch2);
s2.back() = '*';
BOOST_TEST(s2.back() == '*');
s2.back() = ch2;
BOOST_TEST(s2.back() == ch2);
}
// back() const
{
auto const ch1 = s1.at(s1.size()-1);
auto const ch2 = s2.at(s2.size()-1);
BOOST_TEST(cs1.back() == ch1);
BOOST_TEST(cs2.back() == ch2);
}
// data()
{
BOOST_TEST(
string_view(s1.data()) == t.v1);
BOOST_TEST(
string_view(s2.data()) == t.v2);
}
// data() const
{
BOOST_TEST(
string_view(cs1.data()) == t.v1);
BOOST_TEST(
string_view(cs2.data()) == t.v2);
}
// c_str()
{
BOOST_TEST(
string_view(cs1.c_str()) == t.v1);
BOOST_TEST(
string_view(cs2.c_str()) == t.v2);
}
// operator string_view()
{
BOOST_TEST(
string_view(cs1) == t.v1);
BOOST_TEST(
string_view(cs2) == t.v2);
}
}
void
testIterators()
{
string s = "abc";
auto const& ac(s);
{
auto it = s.begin();
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(it == s.end());
}
{
auto it = s.cbegin();
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(it == s.cend());
}
{
auto it = ac.begin();
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(it == ac.end());
}
{
auto it = s.end();
--it; BOOST_TEST(*it == 'c');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'a');
BOOST_TEST(it == s.begin());
}
{
auto it = s.cend();
--it; BOOST_TEST(*it == 'c');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'a');
BOOST_TEST(it == s.cbegin());
}
{
auto it = ac.end();
--it; BOOST_TEST(*it == 'c');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'a');
BOOST_TEST(it == ac.begin());
}
{
auto it = s.rbegin();
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(it == s.rend());
}
{
auto it = s.crbegin();
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(it == s.crend());
}
{
auto it = ac.rbegin();
BOOST_TEST(*it == 'c'); ++it;
BOOST_TEST(*it == 'b'); it++;
BOOST_TEST(*it == 'a'); ++it;
BOOST_TEST(it == ac.rend());
}
{
auto it = s.rend();
--it; BOOST_TEST(*it == 'a');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'c');
BOOST_TEST(it == s.rbegin());
}
{
auto it = s.crend();
--it; BOOST_TEST(*it == 'a');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'c');
BOOST_TEST(it == s.crbegin());
}
{
auto it = ac.rend();
--it; BOOST_TEST(*it == 'a');
it--; BOOST_TEST(*it == 'b');
--it; BOOST_TEST(*it == 'c');
BOOST_TEST(it == ac.rbegin());
}
{
string s2;
string const& cs2(s2);
BOOST_TEST(std::distance(
s2.begin(), s2.end()) == 0);
BOOST_TEST(std::distance(
cs2.begin(), cs2.end()) == 0);
BOOST_TEST(std::distance(
s2.rbegin(), s2.rend()) == 0);
BOOST_TEST(std::distance(
cs2.rbegin(), cs2.rend()) == 0);
}
}
void
testCapacity()
{
test_vectors const t;
// empty()
{
{
string s;
BOOST_TEST(s.empty());
}
{
string s = "abc";
BOOST_TEST(! s.empty());
}
}
// size()
// max_size()
{
string s = "abc";
BOOST_TEST(s.size() == 3);
BOOST_TEST(s.max_size() < string::npos);
}
// reserve(size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.append(t.v1);
s.append(t.v2);
s.reserve(0);
BOOST_TEST(s.size() ==
t.v1.size() + t.v2.size());
s.reserve(t.v1.size() + t.v2.size());
BOOST_TEST(s.size() ==
t.v1.size() + t.v2.size());
s.reserve(s.size() * 2);
BOOST_TEST(s.capacity() >
t.v1.size() + t.v2.size());
s.resize(t.v1.size());
s.reserve(t.v1.size());
BOOST_TEST(s == t.v1);
});
}
// capacity()
{
// implied
}
// shrink_to_fit()
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
string::size_type cap;
cap = s.capacity();
s.shrink_to_fit();
BOOST_TEST(s.capacity() == cap);
s.reserve(s.capacity() + 1);
s.shrink_to_fit();
BOOST_TEST(s.capacity() == cap);
s.resize(cap * 3, '*');
cap = s.capacity();
s.resize(cap - 1);
s.shrink_to_fit();
BOOST_TEST(s.capacity() == cap);
s.resize(cap / 2);
BOOST_TEST(s.capacity() == cap);
s.shrink_to_fit();
BOOST_TEST(s.capacity() < cap);
});
}
void
testClear()
{
test_vectors const t;
// clear()
{
{
string s(t.v1);
s.clear();
BOOST_TEST(s.empty());
BOOST_TEST(s.size() == 0);
BOOST_TEST(s.capacity() > 0);
}
{
string s(t.v2);
s.clear();
BOOST_TEST(s.empty());
BOOST_TEST(s.size() == 0);
BOOST_TEST(s.capacity() > 0);
}
}
}
void
testInsert()
{
test_vectors const t;
// insert(size_type, size_type, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, 3, '*');
BOOST_TEST(s == std::string(
t.v1).insert(1, 3, '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, 3, '*');
BOOST_TEST(s == std::string(
t.v2).insert(1, 3, '*'));
});
// pos out of range
{
string s(t.v1);
BOOST_TEST_THROWS(
(s.insert(s.size() + 2, 1, '*')),
std::out_of_range);
}
// size > max_size
{
string s(t.v1);
BOOST_TEST_THROWS(
(s.insert(1, "", s.max_size())),
std::length_error);
}
}
// insert(size_type, char const*)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, "***");
BOOST_TEST(s == std::string(
t.v1).insert(1, "***"));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, "***");
BOOST_TEST(s == std::string(
t.v2).insert(1, "***"));
});
// pos out of range
{
string s(t.v1);
BOOST_TEST_THROWS(
(s.insert(s.size() + 2, "*", 1)),
std::out_of_range);
}
}
// insert(size_type, char const*, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, "*****", 3);
BOOST_TEST(s == std::string(
t.v1).insert(1, "*****", 3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, "*****", 3);
BOOST_TEST(s == std::string(
t.v2).insert(1, "*****", 3));
});
}
// insert(size_type, string const&)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, string(t.v2));
BOOST_TEST(s == std::string(
t.v1).insert(1, t.s2));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, string(t.v1));
BOOST_TEST(s == std::string(
t.v2).insert(1, t.s1));
});
}
// insert(size_type, string const&, size_type, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, string(t.v2), 1, 3);
BOOST_TEST(s == std::string(
t.v1).insert(1, t.s2, 1, 3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, string(t.v1), 1, 3);
BOOST_TEST(s == std::string(
t.v2).insert(1, t.s1, 1, 3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(1, string(t.v2), 1);
BOOST_TEST(s == std::string(
t.v1).insert(1, t.s2, 1, std::string::npos));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(1, string(t.v1), 1);
BOOST_TEST(s == std::string(
t.v2).insert(1, t.s1, 1, std::string::npos));
});
}
// insert(const_iterator, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
BOOST_TEST(
*s.insert(s.begin()+2, '*') == '*');
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
BOOST_TEST(
*s.insert(s.begin()+2, '*') == '*');
});
}
// insert(const_iterator, size_type, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
BOOST_TEST(string_view(
s.insert(s.begin()+2, 3, '*'), 5) ==
"***cd");
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
BOOST_TEST(string_view(
s.insert(s.begin()+2, 3, '*'), 5) ==
"***CD");
});
}
// insert(const_iterator, InputIt, InputIt)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(s.begin()+2, t.s2.begin(), t.s2.end());
std::string cs(t.s1);
cs.insert(2, &t.s2[0], t.s2.size());
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(s.begin()+2, t.s1.begin(), t.s1.end());
std::string cs(t.s2);
cs.insert(2, &t.s1[0], t.s1.size());
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(s.begin()+2,
make_input_iterator(t.s2.begin()),
make_input_iterator(t.s2.end()));
std::string cs(t.s1);
cs.insert(2, &t.s2[0], t.s2.size());
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(s.begin()+2,
make_input_iterator(t.s1.begin()),
make_input_iterator(t.s1.end()));
std::string cs(t.s2);
cs.insert(2, &t.s1[0], t.s1.size());
BOOST_TEST(s == cs);
});
}
// insert(const_iterator, initializer_list)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(s.begin()+2, INIT2);
std::string cs(t.s1);
cs.insert(2, &t.s2[0], t.s2.size());
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(s.begin()+2, INIT1);
std::string cs(t.s2);
cs.insert(2, &t.s1[0], t.s1.size());
BOOST_TEST(s == cs);
});
}
// insert(const_iterator, string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(2, string_view(t.v2));
std::string cs(t.v1);
cs.insert(2, t.s2);
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(2, string_view(t.v1));
std::string cs(t.v2);
cs.insert(2, t.s1);
BOOST_TEST(s == cs);
});
}
// insert(const_iterator, string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.insert(2, string_view(t.v2), 2, 3);
std::string cs(t.v1);
cs.insert(2, t.s2, 2, 3);
BOOST_TEST(s == cs);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.insert(2, string_view(t.v1), 2, 3);
std::string cs(t.v2);
cs.insert(2, t.s1, 2, 3);
BOOST_TEST(s == cs);
});
}
}
void
testErase()
{
test_vectors const t;
// erase(size_type, size_type)
{
{
string s(t.v1);
s.erase(1, 3);
BOOST_TEST(s ==
std::string(t.v1).erase(1, 3));
}
{
string s(t.v2);
s.erase(1, 3);
BOOST_TEST(s ==
std::string(t.v2).erase(1, 3));
}
{
string s(t.v1);
s.erase(3);
BOOST_TEST(s ==
std::string(t.v1).erase(3));
}
{
string s(t.v2);
s.erase(3);
BOOST_TEST(s ==
std::string(t.v2).erase(3));
}
{
string s(t.v1);
s.erase();
BOOST_TEST(s ==
std::string(t.v1).erase());
}
{
string s(t.v2);
s.erase();
BOOST_TEST(s ==
std::string(t.v2).erase());
}
{
string s(t.v1);
BOOST_TEST_THROWS(
(s.erase(t.v1.size() + 1, 1)),
std::out_of_range);
}
}
// iterator erase(const_iterator)
{
{
string s(t.v1);
std::string s2(t.v1);
s.erase(s.begin() + 3);
s2.erase(s2.begin() + 3);
BOOST_TEST(s == s2);
}
{
string s(t.v2);
std::string s2(t.v2);
s.erase(s.begin() + 3);
s2.erase(s2.begin() + 3);
BOOST_TEST(s == s2);
}
}
// iterator erase(const_iterator, const_iterator)
{
string s(t.v1);
std::string s2(t.v1);
s.erase(s.begin() + 1, s.begin() + 3);
s2.erase(s2.begin() + 1, s2.begin() + 3);
BOOST_TEST(s == s2);
}
}
void
testPushPop()
{
test_vectors const t;
// push_back(char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
for(auto ch : t.v1)
s.push_back(ch);
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
for(auto ch : t.v2)
s.push_back(ch);
BOOST_TEST(s == t.v2);
});
}
// pop_back(char)
{
{
string s(t.v1);
while(! s.empty())
s.pop_back();
BOOST_TEST(s.empty());
BOOST_TEST(s.capacity() > 0);
}
{
string s(t.v2);
while(! s.empty())
s.pop_back();
BOOST_TEST(s.empty());
BOOST_TEST(s.capacity() > 0);
}
}
}
void
testAppend()
{
test_vectors const t;
// append(size_type, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.v2.size(), '*');
BOOST_TEST(s == t.s1 +
std::string(t.v2.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.v1.size(), '*');
BOOST_TEST(s == t.s2 +
std::string(t.v1.size(), '*'));
});
}
// append(string)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(string(t.v2));
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(string(t.v1));
BOOST_TEST(s == t.s2 + t.s1);
});
}
// append(string, size_type, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(string(t.v2), 3);
BOOST_TEST(s == t.s1 + t.s2.substr(3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(string(t.v1), 3);
BOOST_TEST(s == t.s2 + t.s1.substr(3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(string(t.v2), 2, 3);
BOOST_TEST(s == t.s1 + t.s2.substr(2, 3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(string(t.v1), 2, 3);
BOOST_TEST(s == t.s2 + t.s1.substr(2, 3));
});
}
// append(char const*)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.s2.c_str());
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.s1.c_str());
BOOST_TEST(s == t.s2 + t.s1);
});
}
// append(char const*, size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.s2.c_str(), 5);
BOOST_TEST(s == t.s1 + t.s2.substr(0, 5));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.s1.c_str(), 5);
BOOST_TEST(s == t.s2 + t.s1.substr(0, 5));
});
}
// append(initializer_list)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(INIT2);
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(INIT1);
BOOST_TEST(s == t.s2 + t.s1);
});
}
// append(InputIt, InputIt)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.s2.begin(), t.s2.end());
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.s1.begin(), t.s1.end());
BOOST_TEST(s == t.s2 + t.s1);
});
// Fails on Visual Studio 2017 C++2a Strict
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(
make_input_iterator(t.s2.begin()),
make_input_iterator(t.s2.end()));
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(
make_input_iterator(t.s1.begin()),
make_input_iterator(t.s1.end()));
BOOST_TEST(s == t.s2 + t.s1);
});
}
// append(string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.v2);
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.v1);
BOOST_TEST(s == t.s2 + t.s1);
});
}
// append(string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.v2, 2);
BOOST_TEST(s == t.s1 + t.s2.substr(2));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.v1, 2);
BOOST_TEST(s == t.s2 + t.s1.substr(2));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s.append(t.v2, 2, 3);
BOOST_TEST(s == t.s1 + t.s2.substr(2, 3));
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s.append(t.v1, 2, 3);
BOOST_TEST(s == t.s2 + t.s1.substr(2, 3));
});
}
}
void
testPlusEquals()
{
test_vectors const t;
// operator+=(string)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s += string(t.v2);
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s += string(t.v1);
BOOST_TEST(s == t.s2 + t.s1);
});
}
// operator+=(char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
for(auto ch : t.v1)
s += ch;
BOOST_TEST(s == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
for(auto ch : t.v2)
s += ch;
BOOST_TEST(s == t.v2);
});
}
// operator+=(char const*)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s += t.s2.c_str();
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s += t.s1.c_str();
BOOST_TEST(s == t.s2 + t.s1);
});
}
// operator+=(initializer_list)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s += INIT2;
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s += INIT1;
BOOST_TEST(s == t.s2 + t.s1);
});
}
// operator+=(string_view)
{
fail_loop([&](storage_ptr const& sp)
{
string s(t.v1, sp);
s += t.v2;
BOOST_TEST(s == t.s1 + t.s2);
});
fail_loop([&](storage_ptr const& sp)
{
string s(t.v2, sp);
s += t.v1;
BOOST_TEST(s == t.s2 + t.s1);
});
}
}
void
testCompare()
{
test_vectors const t;
string const v1 = t.v1;
// compare(string)
BOOST_TEST(v1.compare(string("aaaaaaa")) > 0);
BOOST_TEST(v1.compare(string(t.v1)) == 0);
BOOST_TEST(v1.compare(string("bbbbbbb")) < 0);
// compare(size_type, size_type, string)
BOOST_TEST(v1.compare(2, 3, string("ccc")) > 0);
BOOST_TEST(v1.compare(2, 3, string("cde")) == 0);
BOOST_TEST(v1.compare(2, 3, string("eee")) < 0);
// compare(size_type, size_type, string, size_type, size_type)
BOOST_TEST(v1.compare(2, 3, string("bbbbb"), 1, 3) > 0);
BOOST_TEST(v1.compare(2, 3, string("bcdef"), 1, 3) == 0);
BOOST_TEST(v1.compare(2, 3, string("fffff"), 1, 3) < 0);
// compare(char const*)
BOOST_TEST(v1.compare("aaaaaaa") > 0);
BOOST_TEST(v1.compare(t.s1.c_str()) == 0);
BOOST_TEST(v1.compare("bbbbbbb") < 0);
// compare(size_type, size_type, char const*)
BOOST_TEST(v1.compare(2, 3, "ccc") > 0);
BOOST_TEST(v1.compare(2, 3, "cde") == 0);
BOOST_TEST(v1.compare(2, 3, "eee") < 0);
// compare(size_type, size_type, char const*, size_type)
BOOST_TEST(v1.compare(2, 4, "cccc", 4) > 0);
BOOST_TEST(v1.compare(2, 4, "cdef", 4) == 0);
BOOST_TEST(v1.compare(2, 4, "ffff", 4) < 0);
// compare(string_view s)
BOOST_TEST(v1.compare(string_view("aaaaaaa")) > 0);
BOOST_TEST(v1.compare(t.v1) == 0);
BOOST_TEST(v1.compare(string_view("bbbbbbb")) < 0);
// compare(size_type, size_type, string_view)
BOOST_TEST(v1.compare(2, 3, string_view("ccc")) > 0);
BOOST_TEST(v1.compare(2, 3, string_view("cde")) == 0);
BOOST_TEST(v1.compare(2, 3, string_view("eee")) < 0);
// compare(size_type, size_type, string_view, size_type, size_type)
BOOST_TEST(v1.compare(2, 3, string_view("bbbbb"), 1, 3) > 0);
BOOST_TEST(v1.compare(2, 3, string_view("bcdef"), 1, 3) == 0);
BOOST_TEST(v1.compare(2, 3, string_view("fffff"), 1, 3) < 0);
}
void
testStartEndsWith()
{
test_vectors const t;
string const v1 = t.v1;
string const v2 = t.v2;
// starts_with(string_view)
{
BOOST_TEST(v1.starts_with(string_view("abc")));
BOOST_TEST(v2.starts_with(string_view("ABC")));
BOOST_TEST(! v1.starts_with(string_view("xyz")));
BOOST_TEST(! v2.starts_with(string_view("XYZ")));
}
// starts_with(char)
{
BOOST_TEST(v1.starts_with('a'));
BOOST_TEST(v2.starts_with('A'));
BOOST_TEST(! v1.starts_with('x'));
BOOST_TEST(! v2.starts_with('X'));
}
// starts_with(char const*)
{
BOOST_TEST(v1.starts_with("abc"));
BOOST_TEST(v2.starts_with("ABC"));
BOOST_TEST(! v1.starts_with("xyz"));
BOOST_TEST(! v2.starts_with("XYZ"));
}
// ends_with(string_view)
{
BOOST_TEST(v1.ends_with(last_of(t.s1,3)));
BOOST_TEST(v2.ends_with(last_of(t.s2,3)));
BOOST_TEST(! v1.ends_with(string_view("abc")));
BOOST_TEST(! v2.ends_with(string_view("ABC")));
}
// ends_with(char)
{
BOOST_TEST(v1.ends_with(last_of(t.s1, 1)[0]));
BOOST_TEST(v2.ends_with(last_of(t.s2, 1)[0]));
BOOST_TEST(! v1.ends_with('a'));
BOOST_TEST(! v2.ends_with('A'));
}
// ends_with(char const*)
{
BOOST_TEST(v1.ends_with(last_of(t.s1, 3).data()));
BOOST_TEST(v2.ends_with(last_of(t.s2, 3).data()));
BOOST_TEST(! v1.ends_with("abc"));
BOOST_TEST(! v2.ends_with("ABC"));
}
}
void
testReplace()
{
}
void
testSubStr()
{
test_vectors const t;
string const s1 = t.v1;
string const s2 = t.v2;
// substr(size_type, size_type)
BOOST_TEST(s1.substr() == t.v1);
BOOST_TEST(s1.substr(1) == t.v1.substr(1));
BOOST_TEST(s1.substr(1, 3) == t.v1.substr(1, 3));
BOOST_TEST(s2.substr() == t.v2);
BOOST_TEST(s2.substr(1) == t.v2.substr(1));
BOOST_TEST(s2.substr(1, 3) == t.v2.substr(1, 3));
}
void
testCopy()
{
test_vectors const t;
// copy(char*, count, pos)
{
{
string s(t.v1);
std::string d;
d.resize(s.size());
s.copy(&d[0], d.size(), 0);
BOOST_TEST(d == t.v1);
}
{
string s(t.v1);
std::string d;
d.resize(s.size());
s.copy(&d[0], d.size());
BOOST_TEST(d == t.v1);
}
}
}
void
testResize()
{
test_vectors const t;
// resize(size_type)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v1.size());
BOOST_TEST(s.size() == t.v1.size());
BOOST_TEST(s == string(t.v1.size(), '\0'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v2.size());
BOOST_TEST(s.size() == t.v2.size());
BOOST_TEST(s == string(t.v2.size(), '\0'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v1.size());
s.resize(t.v2.size());
BOOST_TEST(s == string(t.v2.size(), '\0'));
s.resize(t.v1.size());
BOOST_TEST(s == string(t.v1.size(), '\0'));
});
}
// resize(size_type, char)
{
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v1.size(), '*');
BOOST_TEST(s.size() == t.v1.size());
BOOST_TEST(s == string(t.v1.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v2.size(), '*');
BOOST_TEST(s.size() == t.v2.size());
BOOST_TEST(s == string(t.v2.size(), '*'));
});
fail_loop([&](storage_ptr const& sp)
{
string s(sp);
s.resize(t.v1.size(), '*');
s.resize(t.v2.size(), '*');
BOOST_TEST(s == string(t.v2.size(), '*'));
s.resize(t.v1.size());
BOOST_TEST(s == string(t.v1.size(), '*'));
});
}
}
void
testSwap()
{
test_vectors const t;
// swap
{
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v1, sp);
string s2(t.v2, sp);
s1.swap(s2);
BOOST_TEST(s1 == t.v2);
BOOST_TEST(s2 == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v1, sp);
string s2(t.v2, sp);
swap(s1, s2);
BOOST_TEST(s1 == t.v2);
BOOST_TEST(s2 == t.v1);
});
fail_loop([&](storage_ptr const& sp)
{
string s1(t.v1);
string s2(t.v2, sp);
s1.swap(s2);
BOOST_TEST(s1 == t.v2);
BOOST_TEST(s2 == t.v1);
});
}
}
void
testFind()
{
test_vectors const t;
string const s1 = t.v1;
string const s2 = t.v2;
// find(string, size_type)
BOOST_TEST(s1.find(string("bcd")) == 1);
BOOST_TEST(s1.find(string("cde"), 1) == 2);
BOOST_TEST(s1.find(string("efg"), 5) == string::npos);
// find(char const*, size_type, size_type)
BOOST_TEST(s1.find("bcd*", 0, 3) == 1);
BOOST_TEST(s1.find("cde*", 1, 3) == 2);
BOOST_TEST(s1.find("efg*", 5, 3) == string::npos);
// find(char const*, size_type)
BOOST_TEST(s1.find("bcd", 0) == 1);
BOOST_TEST(s1.find("cde", 1) == 2);
BOOST_TEST(s1.find("efg", 5) == string::npos);
// find(char, size_type)
BOOST_TEST(s1.find('b') == 1);
BOOST_TEST(s1.find('c', 1) == 2);
BOOST_TEST(s1.find('e', 5) == string::npos);
// find(T const, size_type pos)
BOOST_TEST(s1.find(string_view("bcd")) == 1);
BOOST_TEST(s1.find(string_view("cde"), 1) == 2);
BOOST_TEST(s1.find(string_view("efg"), 5) == string::npos);
}
void
testRfind()
{
}
void
testFindFirstOf()
{
}
void
testFindNotFirstOf()
{
}
void
testFindLastOf()
{
}
void
testFindNotLastOf()
{
}
void
testNonMembers()
{
test_vectors const t;
string const s1(t.v1);
string const s2(t.v2);
auto const v1(t.v1);
auto const v2(t.v2);
auto const c1 = t.s1.c_str();
auto const c2 = t.s2.c_str();
BOOST_TEST(! operator< (s1, s2));
BOOST_TEST(! operator< (s1, v2));
BOOST_TEST(! operator< (s1, c2));
BOOST_TEST(! operator<=(s1, s2));
BOOST_TEST(! operator<=(s1, v2));
BOOST_TEST(! operator<=(s1, c2));
BOOST_TEST(! operator==(s1, s2));
BOOST_TEST(! operator==(s1, v2));
BOOST_TEST(! operator==(s1, c2));
BOOST_TEST( operator!=(s1, s2));
BOOST_TEST( operator!=(s1, v2));
BOOST_TEST( operator!=(s1, c2));
BOOST_TEST( operator>=(s1, s2));
BOOST_TEST( operator>=(s1, v2));
BOOST_TEST( operator>=(s1, c2));
BOOST_TEST( operator> (s1, s2));
BOOST_TEST( operator> (s1, v2));
BOOST_TEST( operator> (s1, c2));
BOOST_TEST( operator< (s2, s1));
BOOST_TEST( operator< (s2, v1));
BOOST_TEST( operator< (s2, c1));
BOOST_TEST( operator<=(s2, s1));
BOOST_TEST( operator<=(s2, v1));
BOOST_TEST( operator<=(s2, c1));
BOOST_TEST( operator!=(s2, s1));
BOOST_TEST( operator!=(s2, v1));
BOOST_TEST( operator!=(s2, c1));
BOOST_TEST(! operator==(s2, s1));
BOOST_TEST(! operator==(s2, v1));
BOOST_TEST(! operator==(s2, c1));
BOOST_TEST(! operator>=(s2, s1));
BOOST_TEST(! operator>=(s2, v1));
BOOST_TEST(! operator>=(s2, c1));
BOOST_TEST(! operator> (s2, s1));
BOOST_TEST(! operator> (s2, v1));
BOOST_TEST(! operator> (s2, c1));
BOOST_TEST( operator< (s2, s1));
BOOST_TEST( operator< (v2, s1));
BOOST_TEST( operator< (c2, s1));
BOOST_TEST( operator<=(s2, s1));
BOOST_TEST( operator<=(v2, s1));
BOOST_TEST( operator<=(c2, s1));
BOOST_TEST( operator!=(s2, s1));
BOOST_TEST( operator!=(v2, s1));
BOOST_TEST( operator!=(c2, s1));
BOOST_TEST(! operator==(s2, s1));
BOOST_TEST(! operator==(v2, s1));
BOOST_TEST(! operator==(c2, s1));
BOOST_TEST(! operator>=(s2, s1));
BOOST_TEST(! operator>=(v2, s1));
BOOST_TEST(! operator>=(c2, s1));
BOOST_TEST(! operator> (s2, s1));
BOOST_TEST(! operator> (v2, s1));
BOOST_TEST(! operator> (c2, s1));
BOOST_TEST(! operator< (s1, s2));
BOOST_TEST(! operator< (v1, s2));
BOOST_TEST(! operator< (c1, s2));
BOOST_TEST(! operator<=(s1, s2));
BOOST_TEST(! operator<=(v1, s2));
BOOST_TEST(! operator<=(c1, s2));
BOOST_TEST(! operator==(s1, s2));
BOOST_TEST(! operator==(v1, s2));
BOOST_TEST(! operator==(c1, s2));
BOOST_TEST( operator!=(s1, s2));
BOOST_TEST( operator!=(v1, s2));
BOOST_TEST( operator!=(c1, s2));
BOOST_TEST( operator>=(s1, s2));
BOOST_TEST( operator>=(v1, s2));
BOOST_TEST( operator>=(c1, s2));
BOOST_TEST( operator> (s1, s2));
BOOST_TEST( operator> (v1, s2));
BOOST_TEST( operator> (c1, s2));
std::stringstream ss;
string s = "Hello, world";
ss << s;
BOOST_TEST(ss.str() == s);
}
void
run()
{
testConstruction();
testAssignment();
testAssign();
testElementAccess();
testIterators();
testCapacity();
testClear();
testInsert();
testErase();
testPushPop();
testAppend();
testPlusEquals();
testCompare();
testStartEndsWith();
testReplace(); //
testSubStr();
testCopy();
testResize();
testSwap();
testFind();
testRfind(); //
testFindFirstOf(); //
testFindNotFirstOf(); //
testFindLastOf(); //
testFindNotLastOf(); //
testNonMembers();
}
};
TEST_SUITE(string_test, "boost.json.string");
} // json
} // boost
Reference in New Issue View Git Blame Copy Permalink