forked from boostorg/core
Contribute span implementation
This commit is contained in:
Glen Fernandes
@@ -8,6 +8,7 @@
|
||||
|
||||
import modules ;
|
||||
import testing ;
|
||||
import ../../config/checks/config : requires ;
|
||||
|
||||
# quick test (for CI)
|
||||
run quick.cpp ;
|
||||
@@ -269,5 +270,12 @@ run sv_lt_test.cpp ;
|
||||
run sv_stream_insert_test.cpp ;
|
||||
run sv_conversion_test.cpp ;
|
||||
|
||||
run span_test.cpp : : : [ requires cxx11_constexpr cxx11_decltype ] ;
|
||||
run span_types_test.cpp : : : [ requires cxx11_constexpr cxx11_decltype ] ;
|
||||
run span_constructible_test.cpp : : : [ requires cxx11_constexpr cxx11_decltype ] ;
|
||||
run span_deduction_guide_test.cpp : : : [ requires cpp_deduction_guides ] ;
|
||||
run as_bytes_test.cpp : : : [ requires cpp_lib_byte ] ;
|
||||
run as_writable_bytes_test.cpp : : : [ requires cpp_lib_byte ] ;
|
||||
|
||||
use-project /boost/core/swap : ./swap ;
|
||||
build-project ./swap ;
|
||||
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
void test_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<const std::byte> s =
|
||||
boost::as_bytes(boost::span<int>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), reinterpret_cast<const std::byte*>(&a[0]));
|
||||
BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
|
||||
}
|
||||
|
||||
void test_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<const std::byte, sizeof(int) * 4> s =
|
||||
boost::as_bytes(boost::span<int, 4>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), reinterpret_cast<const std::byte*>(&a[0]));
|
||||
BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_dynamic();
|
||||
test_static();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -0,0 +1,34 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
void test_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<std::byte> s =
|
||||
boost::as_writable_bytes(boost::span<int>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), reinterpret_cast<std::byte*>(&a[0]));
|
||||
BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
|
||||
}
|
||||
|
||||
void test_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<std::byte, sizeof(int) * 4> s =
|
||||
boost::as_writable_bytes(boost::span<int, 4>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), reinterpret_cast<std::byte*>(&a[0]));
|
||||
BOOST_TEST_EQ(s.size(), sizeof(int) * 4);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_dynamic();
|
||||
test_static();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -0,0 +1,192 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
template<class T>
|
||||
struct range {
|
||||
T* data() {
|
||||
return 0;
|
||||
}
|
||||
|
||||
const T* data() const {
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::size_t size() const {
|
||||
return 0;
|
||||
}
|
||||
};
|
||||
|
||||
struct base { };
|
||||
|
||||
struct derived
|
||||
: base { };
|
||||
|
||||
void test_default()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<
|
||||
boost::span<int> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_default_constructible<
|
||||
boost::span<int, 0> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_default_constructible<
|
||||
boost::span<int, 2> >));
|
||||
}
|
||||
|
||||
void test_data_size()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
int*, std::size_t>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
int*, std::size_t>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
int, std::size_t>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
const int*, std::size_t>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
|
||||
derived*, std::size_t>));
|
||||
}
|
||||
|
||||
void test_first_last()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
int*, int*>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
int*, const int*>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
int*, int*>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
int, int*>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
const int*, int*>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
|
||||
derived*, derived*>));
|
||||
}
|
||||
|
||||
void test_array()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
int(&)[4]>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
|
||||
int(&)[4]>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
|
||||
int(&)[4]>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
|
||||
int(&)[2]>));
|
||||
}
|
||||
|
||||
void test_std_array()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
std::array<int, 4>&>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
std::array<int, 4>&>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
|
||||
std::array<int, 4>&>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
|
||||
4>, std::array<int, 4>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
std::array<const int, 4>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
|
||||
std::array<derived, 4>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
|
||||
std::array<int, 4>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
|
||||
std::array<const int, 4>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base, 4>,
|
||||
std::array<derived, 4>&>));
|
||||
}
|
||||
|
||||
void test_const_std_array()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
const std::array<int, 4> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
|
||||
4>, const std::array<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
const std::array<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const
|
||||
base>, const std::array<derived, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const int,
|
||||
2>, const std::array<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
|
||||
const std::array<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<const
|
||||
base, 4>, const std::array<derived, 4> >));
|
||||
}
|
||||
|
||||
void test_range()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
range<int>&>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
range<int>&>));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
range<int> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
int*>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
range<int> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
const range<int>&>));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
|
||||
range<derived>&>));
|
||||
}
|
||||
|
||||
void test_span()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int>,
|
||||
boost::span<int> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int>,
|
||||
boost::span<int, 4> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<int, 4>,
|
||||
boost::span<int> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_constructible<boost::span<const int,
|
||||
4>, boost::span<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int>,
|
||||
boost::span<const int> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base>,
|
||||
boost::span<derived> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 2>,
|
||||
boost::span<int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<int, 4>,
|
||||
boost::span<const int, 4> >));
|
||||
BOOST_TEST_TRAIT_FALSE((std::is_constructible<boost::span<base, 4>,
|
||||
boost::span<derived, 4> >));
|
||||
}
|
||||
|
||||
void test_copy()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_copy_constructible<
|
||||
boost::span<int> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_copy_constructible<
|
||||
boost::span<int, 4> >));
|
||||
}
|
||||
|
||||
void test_assign()
|
||||
{
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_copy_assignable<
|
||||
boost::span<int> >));
|
||||
BOOST_TEST_TRAIT_TRUE((std::is_copy_assignable<
|
||||
boost::span<int, 4> >));
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_default();
|
||||
test_data_size();
|
||||
test_first_last();
|
||||
test_array();
|
||||
test_std_array();
|
||||
test_const_std_array();
|
||||
test_range();
|
||||
test_span();
|
||||
test_copy();
|
||||
test_assign();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -0,0 +1,109 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
template<class T>
|
||||
class range {
|
||||
public:
|
||||
T* data() {
|
||||
return &v_[0];
|
||||
}
|
||||
|
||||
std::size_t size() const {
|
||||
return 4;
|
||||
}
|
||||
|
||||
private:
|
||||
T v_[4];
|
||||
};
|
||||
|
||||
void test_data_size()
|
||||
{
|
||||
int a[4];
|
||||
boost::span s(&a[0], 4);
|
||||
BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_first_last()
|
||||
{
|
||||
int a[4];
|
||||
boost::span s(&a[0], &a[4]);
|
||||
BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_array()
|
||||
{
|
||||
int a[4];
|
||||
boost::span s(a);
|
||||
BOOST_TEST_EQ(s.extent, 4);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_std_array()
|
||||
{
|
||||
std::array<int, 4> a;
|
||||
boost::span s(a);
|
||||
BOOST_TEST_EQ(s.extent, 4);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_const_std_array()
|
||||
{
|
||||
const std::array<int, 4> a = std::array<int, 4>();
|
||||
boost::span s(a);
|
||||
BOOST_TEST_EQ(s.extent, 4);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_range()
|
||||
{
|
||||
range<int> c;
|
||||
boost::span s(c);
|
||||
BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
|
||||
BOOST_TEST_EQ(s.data(), c.data());
|
||||
BOOST_TEST_EQ(s.size(), c.size());
|
||||
}
|
||||
|
||||
void test_span_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span s(boost::span<int>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.extent, boost::dynamic_extent);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_span_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span s(boost::span<int, 4>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.extent, 4);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_data_size();
|
||||
test_first_last();
|
||||
test_array();
|
||||
test_std_array();
|
||||
test_const_std_array();
|
||||
test_range();
|
||||
test_span_dynamic();
|
||||
test_span_static();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -0,0 +1,425 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test.hpp>
|
||||
|
||||
template<class T>
|
||||
class range {
|
||||
public:
|
||||
T* data() {
|
||||
return &v_[0];
|
||||
}
|
||||
|
||||
std::size_t size() const {
|
||||
return 4;
|
||||
}
|
||||
|
||||
private:
|
||||
T v_[4];
|
||||
};
|
||||
|
||||
void test_extent()
|
||||
{
|
||||
BOOST_TEST_EQ(boost::span<int>::extent,
|
||||
boost::dynamic_extent);
|
||||
BOOST_TEST_EQ((boost::span<int, 2>::extent), 2);
|
||||
}
|
||||
|
||||
void test_default_construct_dynamic()
|
||||
{
|
||||
boost::span<int> s;
|
||||
BOOST_TEST_EQ(s.data(), static_cast<int*>(0));
|
||||
BOOST_TEST_EQ(s.size(), 0);
|
||||
}
|
||||
|
||||
void test_default_construct_static()
|
||||
{
|
||||
boost::span<int, 0> s;
|
||||
BOOST_TEST_EQ(s.data(), static_cast<int*>(0));
|
||||
BOOST_TEST_EQ(s.size(), 0);
|
||||
}
|
||||
|
||||
void test_construct_data_size()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s(&a[0], 4);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_first_last()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s(&a[0], &a[4]);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_array_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s(a);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_array_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 4> s(a);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_std_array_dynamic()
|
||||
{
|
||||
std::array<int, 4> a;
|
||||
boost::span<int> s(a);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_construct_std_array_static()
|
||||
{
|
||||
std::array<int, 4> a;
|
||||
boost::span<int, 4> s(a);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_construct_const_std_array_dynamic()
|
||||
{
|
||||
const std::array<int, 4> a = std::array<int, 4>();
|
||||
boost::span<const int> s(a);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_construct_const_std_array_static()
|
||||
{
|
||||
const std::array<int, 4> a = std::array<int, 4>();
|
||||
boost::span<const int, 4> s(a);
|
||||
BOOST_TEST_EQ(s.data(), a.data());
|
||||
BOOST_TEST_EQ(s.size(), a.size());
|
||||
}
|
||||
|
||||
void test_construct_range()
|
||||
{
|
||||
range<int> c;
|
||||
boost::span<int> s(c);
|
||||
BOOST_TEST_EQ(s.data(), c.data());
|
||||
BOOST_TEST_EQ(s.size(), c.size());
|
||||
}
|
||||
|
||||
void test_construct_span_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<const int> s(boost::span<int>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_span_dynamic_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s(boost::span<int, 4>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_span_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<const int, 4> s(boost::span<int, 4>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_construct_span_static_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 4> s(boost::span<int>(&a[0], 4));
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_copy_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s1(&a[0], 4);
|
||||
boost::span<int> s2(s1);
|
||||
BOOST_TEST_EQ(s2.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s2.size(), 4);
|
||||
}
|
||||
|
||||
void test_copy_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 4> s1(&a[0], 4);
|
||||
boost::span<int, 4> s2(s1);
|
||||
BOOST_TEST_EQ(s2.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s2.size(), 4);
|
||||
}
|
||||
|
||||
void test_assign_dynamic()
|
||||
{
|
||||
boost::span<int> s;
|
||||
int a[4];
|
||||
s = boost::span<int>(&a[0], 4);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_assign_static()
|
||||
{
|
||||
int a1[4];
|
||||
boost::span<int, 4> s(&a1[0], 4);
|
||||
int a2[4];
|
||||
s = boost::span<int, 4>(&a2[0], 4);
|
||||
BOOST_TEST_EQ(s.data(), &a2[0]);
|
||||
BOOST_TEST_EQ(s.size(), 4);
|
||||
}
|
||||
|
||||
void test_first()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 2> s = boost::span<int>(&a[0],
|
||||
4).first<2>();
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_last()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 2> s = boost::span<int>(&a[0], 4).last<2>();
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_subspan_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s = boost::span<int>(&a[0], 4).subspan<2>();
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_subspan_static()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 2> s = boost::span<int, 4>(&a[0],
|
||||
4).subspan<2>();
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_subspan()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int, 1> s = boost::span<int>(&a[0],
|
||||
4).subspan<2, 1>();
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 1);
|
||||
}
|
||||
|
||||
void test_first_size()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s = boost::span<int>(&a[0], 4).first(2);
|
||||
BOOST_TEST_EQ(s.data(), &a[0]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_last_size()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s = boost::span<int>(&a[0], 4).last(2);
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_subspan_range()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s = boost::span<int>(&a[0], 4).subspan(2);
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 2);
|
||||
}
|
||||
|
||||
void test_subspan_range_count()
|
||||
{
|
||||
int a[4];
|
||||
boost::span<int> s = boost::span<int>(&a[0],
|
||||
4).subspan(2, 1);
|
||||
BOOST_TEST_EQ(s.data(), &a[2]);
|
||||
BOOST_TEST_EQ(s.size(), 1);
|
||||
}
|
||||
|
||||
void test_size()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).size()), 4);
|
||||
}
|
||||
|
||||
void test_size_bytes()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).size_bytes()),
|
||||
4 * sizeof(int));
|
||||
}
|
||||
|
||||
void test_empty_dynamic()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST(boost::span<int>().empty());
|
||||
BOOST_TEST_NOT((boost::span<int>(&a[0], 4).empty()));
|
||||
}
|
||||
|
||||
void test_empty_static()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST((boost::span<int, 0>().empty()));
|
||||
BOOST_TEST_NOT((boost::span<int, 4>(&a[0], 4).empty()));
|
||||
}
|
||||
|
||||
void test_index()
|
||||
{
|
||||
int a[4] = { 1, 2, 3, 4 };
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4)[2]), 3);
|
||||
}
|
||||
|
||||
void test_front()
|
||||
{
|
||||
int a[4] = { 1, 2, 3, 4 };
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).front()), 1);
|
||||
}
|
||||
|
||||
void test_back()
|
||||
{
|
||||
int a[4] = { 1, 2, 3, 4 };
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).back()), 4);
|
||||
}
|
||||
|
||||
void test_data()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).data()), &a[0]);
|
||||
}
|
||||
|
||||
void test_begin()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).begin()), &a[0]);
|
||||
}
|
||||
|
||||
void test_end()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).end()), &a[4]);
|
||||
}
|
||||
|
||||
void test_rbegin()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).rbegin().base()), &a[4]);
|
||||
}
|
||||
|
||||
void test_rend()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).rend().base()), &a[0]);
|
||||
}
|
||||
|
||||
void test_cbegin()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).cbegin()), &a[0]);
|
||||
}
|
||||
|
||||
void test_cend()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).cend()), &a[4]);
|
||||
}
|
||||
|
||||
void test_crbegin()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).crbegin().base()), &a[4]);
|
||||
}
|
||||
|
||||
void test_crend()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((boost::span<int>(&a[0], 4).crend().base()), &a[0]);
|
||||
}
|
||||
|
||||
void test_begin_span()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((begin(boost::span<int>(&a[0], 4))), &a[0]);
|
||||
}
|
||||
|
||||
void test_end_span()
|
||||
{
|
||||
int a[4];
|
||||
BOOST_TEST_EQ((end(boost::span<int>(&a[0], 4))), &a[4]);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_extent();
|
||||
test_default_construct_dynamic();
|
||||
test_default_construct_static();
|
||||
test_construct_data_size();
|
||||
test_construct_first_last();
|
||||
test_construct_array_dynamic();
|
||||
test_construct_array_static();
|
||||
test_construct_std_array_dynamic();
|
||||
test_construct_std_array_static();
|
||||
test_construct_const_std_array_dynamic();
|
||||
test_construct_const_std_array_static();
|
||||
test_construct_range();
|
||||
test_construct_span_dynamic();
|
||||
test_construct_span_dynamic_static();
|
||||
test_construct_span_static();
|
||||
test_construct_span_static_dynamic();
|
||||
test_copy_dynamic();
|
||||
test_copy_static();
|
||||
test_assign_dynamic();
|
||||
test_assign_static();
|
||||
test_first();
|
||||
test_last();
|
||||
test_subspan_dynamic();
|
||||
test_subspan_static();
|
||||
test_subspan();
|
||||
test_first_size();
|
||||
test_last_size();
|
||||
test_subspan_range();
|
||||
test_subspan_range_count();
|
||||
test_size();
|
||||
test_size_bytes();
|
||||
test_empty_dynamic();
|
||||
test_empty_static();
|
||||
test_index();
|
||||
test_front();
|
||||
test_back();
|
||||
test_data();
|
||||
test_begin();
|
||||
test_end();
|
||||
test_rbegin();
|
||||
test_rend();
|
||||
test_cbegin();
|
||||
test_cend();
|
||||
test_crbegin();
|
||||
test_crend();
|
||||
test_begin_span();
|
||||
test_end_span();
|
||||
return boost::report_errors();
|
||||
}
|
||||
@@ -0,0 +1,128 @@
|
||||
/*
|
||||
Copyright 2019 Glen Joseph Fernandes
|
||||
(glenjofe@gmail.com)
|
||||
|
||||
Distributed under the Boost Software License, Version 1.0.
|
||||
(http://www.boost.org/LICENSE_1_0.txt)
|
||||
*/
|
||||
#include <boost/core/span.hpp>
|
||||
#include <boost/core/lightweight_test_trait.hpp>
|
||||
|
||||
void test_element_type()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(int,
|
||||
boost::span<int>::element_type);
|
||||
BOOST_TEST_TRAIT_SAME(char,
|
||||
boost::span<char>::element_type);
|
||||
}
|
||||
|
||||
void test_value_type()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(char,
|
||||
boost::span<char>::value_type);
|
||||
BOOST_TEST_TRAIT_SAME(int,
|
||||
boost::span<int>::value_type);
|
||||
BOOST_TEST_TRAIT_SAME(int,
|
||||
boost::span<const int>::value_type);
|
||||
BOOST_TEST_TRAIT_SAME(int,
|
||||
boost::span<volatile int>::value_type);
|
||||
BOOST_TEST_TRAIT_SAME(int,
|
||||
boost::span<const volatile int>::value_type);
|
||||
}
|
||||
|
||||
void test_size_type()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(std::size_t,
|
||||
boost::span<char>::size_type);
|
||||
BOOST_TEST_TRAIT_SAME(std::size_t,
|
||||
boost::span<int>::size_type);
|
||||
}
|
||||
|
||||
void test_difference_type()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
|
||||
boost::span<char>::difference_type);
|
||||
BOOST_TEST_TRAIT_SAME(std::ptrdiff_t,
|
||||
boost::span<int>::difference_type);
|
||||
}
|
||||
|
||||
void test_pointer()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(char*,
|
||||
boost::span<char>::pointer);
|
||||
BOOST_TEST_TRAIT_SAME(int*,
|
||||
boost::span<int>::pointer);
|
||||
}
|
||||
|
||||
void test_const_pointer()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(const char*,
|
||||
boost::span<char>::const_pointer);
|
||||
BOOST_TEST_TRAIT_SAME(const int*,
|
||||
boost::span<int>::const_pointer);
|
||||
}
|
||||
|
||||
void test_reference()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(char&,
|
||||
boost::span<char>::reference);
|
||||
BOOST_TEST_TRAIT_SAME(int&,
|
||||
boost::span<int>::reference);
|
||||
}
|
||||
|
||||
void test_const_reference()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(const char&,
|
||||
boost::span<char>::const_reference);
|
||||
BOOST_TEST_TRAIT_SAME(const int&,
|
||||
boost::span<int>::const_reference);
|
||||
}
|
||||
|
||||
void test_iterator()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(char*,
|
||||
boost::span<char>::iterator);
|
||||
BOOST_TEST_TRAIT_SAME(int*,
|
||||
boost::span<int>::iterator);
|
||||
}
|
||||
|
||||
void test_const_iterator()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(const char*,
|
||||
boost::span<char>::const_iterator);
|
||||
BOOST_TEST_TRAIT_SAME(const int*,
|
||||
boost::span<int>::const_iterator);
|
||||
}
|
||||
|
||||
void test_reverse_iterator()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(std::reverse_iterator<char*>,
|
||||
boost::span<char>::reverse_iterator);
|
||||
BOOST_TEST_TRAIT_SAME(std::reverse_iterator<int*>,
|
||||
boost::span<int>::reverse_iterator);
|
||||
}
|
||||
|
||||
void test_const_reverse_iterator()
|
||||
{
|
||||
BOOST_TEST_TRAIT_SAME(std::reverse_iterator<const char*>,
|
||||
boost::span<char>::const_reverse_iterator);
|
||||
BOOST_TEST_TRAIT_SAME(std::reverse_iterator<const int*>,
|
||||
boost::span<int>::const_reverse_iterator);
|
||||
}
|
||||
|
||||
int main()
|
||||
{
|
||||
test_element_type();
|
||||
test_value_type();
|
||||
test_size_type();
|
||||
test_difference_type();
|
||||
test_pointer();
|
||||
test_const_pointer();
|
||||
test_reference();
|
||||
test_const_reference();
|
||||
test_iterator();
|
||||
test_const_iterator();
|
||||
test_reverse_iterator();
|
||||
test_const_reverse_iterator();
|
||||
return boost::report_errors();
|
||||
}
|
||||
Reference in New Issue
Block a user