mirror of
https://github.com/bolero-MURAKAMI/Sprout
synced 2024-12-03 21:15:42 +00:00
186 lines
5.7 KiB
C++
186 lines
5.7 KiB
C++
/*=============================================================================
|
|
Copyright (c) 2011-2016 Bolero MURAKAMI
|
|
https://github.com/bolero-MURAKAMI/Sprout
|
|
|
|
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)
|
|
=============================================================================*/
|
|
#ifndef SPROUT_LIBS_ARRAY_TEST_ARRAY_CPP
|
|
#define SPROUT_LIBS_ARRAY_TEST_ARRAY_CPP
|
|
|
|
#include <sprout/array.hpp>
|
|
#include <sprout/container.hpp>
|
|
#include <testspr/tools.hpp>
|
|
|
|
namespace testspr {
|
|
static void array_test() {
|
|
using namespace sprout;
|
|
{
|
|
SPROUT_STATIC_CONSTEXPR int carr[] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
|
|
SPROUT_STATIC_CONSTEXPR auto arr1 = sprout::to_array(carr);
|
|
SPROUT_STATIC_CONSTEXPR auto arr2 = sprout::make_array<int>(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
|
|
SPROUT_STATIC_CONSTEXPR auto arr3 = sprout::make_array(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);
|
|
|
|
TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr1));
|
|
TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr2));
|
|
TESTSPR_BOTH_ASSERT(testspr::equal(carr, arr3));
|
|
|
|
// begin
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr1.begin());
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr2.begin());
|
|
|
|
// cbegin
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr1.cbegin());
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr2.cbegin());
|
|
|
|
// end
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *(arr1.end() - 1));
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *(arr2.end() - 1));
|
|
|
|
// cend
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *(arr1.cend() - 1));
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *(arr2.cend() - 1));
|
|
|
|
// rbegin
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *arr1.rbegin());
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *arr2.rbegin());
|
|
|
|
// crbegin
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *arr1.crbegin());
|
|
TESTSPR_BOTH_ASSERT(carr[9] == *arr2.crbegin());
|
|
|
|
// rend
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *(arr1.rend() - 1));
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *(arr2.rend() - 1));
|
|
|
|
// crend
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *(arr1.crend() - 1));
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *(arr2.crend() - 1));
|
|
|
|
// size
|
|
TESTSPR_BOTH_ASSERT(arr1.size() == 10);
|
|
TESTSPR_BOTH_ASSERT(arr2.size() == 10);
|
|
|
|
// empty
|
|
TESTSPR_BOTH_ASSERT(!arr1.empty());
|
|
TESTSPR_BOTH_ASSERT(!arr2.empty());
|
|
TESTSPR_BOTH_ASSERT((array<int, 0>{{}}.empty()));
|
|
|
|
// max_size
|
|
TESTSPR_BOTH_ASSERT(arr1.max_size() == 10);
|
|
TESTSPR_BOTH_ASSERT(arr2.max_size() == 10);
|
|
|
|
// operator[]
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr1[0]);
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr2[0]);
|
|
|
|
// at
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr1.at(0));
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr2.at(0));
|
|
|
|
// front
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr1.front());
|
|
TESTSPR_BOTH_ASSERT(carr[0] == arr2.front());
|
|
|
|
// back
|
|
TESTSPR_BOTH_ASSERT(carr[9] == arr1.back());
|
|
TESTSPR_BOTH_ASSERT(carr[9] == arr2.back());
|
|
|
|
// data
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr1.data());
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr2.data());
|
|
{
|
|
auto arr = arr1;
|
|
TESTSPR_ASSERT(carr[0] == *arr.data());
|
|
}
|
|
|
|
// c_array
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr1.c_array());
|
|
TESTSPR_BOTH_ASSERT(carr[0] == *arr2.c_array());
|
|
{
|
|
auto arr = arr1;
|
|
TESTSPR_ASSERT(carr[0] == *arr.c_array());
|
|
}
|
|
|
|
// assign
|
|
TESTSPR_BOTH_ASSERT(testspr::equal(arr1.assign(-1), sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}));
|
|
{
|
|
auto arr = arr1;
|
|
arr.assign(-1);
|
|
TESTSPR_ASSERT(testspr::equal(arr, sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}));
|
|
}
|
|
|
|
// fill
|
|
TESTSPR_BOTH_ASSERT(testspr::equal(arr1.fill(-1), sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}));
|
|
{
|
|
auto arr = arr1;
|
|
arr.fill(-1);
|
|
TESTSPR_ASSERT(testspr::equal(arr, sprout::array<int, 10>{{-1, -1, -1, -1, -1, -1, -1, -1, -1, -1}}));
|
|
}
|
|
|
|
// swap
|
|
{
|
|
auto arr1 = sprout::array<int, 2>{{1, 2}};
|
|
auto arr2 = sprout::array<int, 2>{{-1, -2}};
|
|
arr1.swap(arr2);
|
|
TESTSPR_ASSERT(arr1[0] == -1);
|
|
}
|
|
|
|
// operator=
|
|
{
|
|
auto arr1 = sprout::array<int, 2>{{1, 2}};
|
|
arr1 = sprout::array<int, 2>{{-1, -2}};
|
|
TESTSPR_ASSERT(arr1[0] == -1);
|
|
}
|
|
|
|
// operator==
|
|
TESTSPR_BOTH_ASSERT(arr1 == arr2);
|
|
|
|
// operator!=
|
|
TESTSPR_BOTH_ASSERT(!(arr1 != arr2));
|
|
|
|
// operator<
|
|
TESTSPR_BOTH_ASSERT(!(arr1 < arr2));
|
|
|
|
// operator>
|
|
TESTSPR_BOTH_ASSERT(!(arr1 > arr2));
|
|
|
|
// operator<=
|
|
TESTSPR_BOTH_ASSERT(arr1 <= arr2);
|
|
|
|
// operator>=
|
|
TESTSPR_BOTH_ASSERT(arr1 >= arr2);
|
|
|
|
// get
|
|
TESTSPR_BOTH_ASSERT(sprout::tuples::get<0>(arr1) == 1);
|
|
TESTSPR_BOTH_ASSERT(sprout::tuples::get<1>(arr1) == 2);
|
|
{
|
|
auto arr4 = arr1;
|
|
TESTSPR_ASSERT(sprout::tuples::get<0>(arr4) == 1);
|
|
TESTSPR_ASSERT(sprout::tuples::get<1>(arr4) == 2);
|
|
}
|
|
|
|
// tuple_size
|
|
TESTSPR_BOTH_ASSERT(sprout::tuples::tuple_size<decltype(arr1)>::value == 10);
|
|
|
|
// tuple_element
|
|
TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<0, decltype(arr1)>::type, int const>::value));
|
|
TESTSPR_BOTH_ASSERT((std::is_same<sprout::tuples::tuple_element<1, decltype(arr1)>::type, int const>::value));
|
|
|
|
// is_array
|
|
TESTSPR_BOTH_ASSERT(sprout::is_array_class<decltype(arr1)>::value);
|
|
TESTSPR_BOTH_ASSERT(!sprout::is_array_class<int>::value);
|
|
|
|
// sprout::to_hash, sprout::hash
|
|
TESTSPR_BOTH_ASSERT(sprout::to_hash(arr1) == sprout::hash<decltype(arr1)>()(arr1));
|
|
TESTSPR_BOTH_ASSERT(sprout::to_hash(arr1) != sprout::to_hash(sprout::array<int, 10>{{}}));
|
|
}
|
|
}
|
|
} // namespace testspr
|
|
|
|
#ifndef TESTSPR_CPP_INCLUDE
|
|
# define TESTSPR_TEST_FUNCTION testspr::array_test
|
|
# include <testspr/include_main.hpp>
|
|
#endif
|
|
|
|
#endif // #ifndef SPROUT_LIBS_ARRAY_TEST_ARRAY_CPP
|