Skip to content

Commit 891416c

Browse files
author
Julian LALU
committed
Add hud::pair piecewise constructor tests
1 parent 211868f commit 891416c

File tree

2 files changed

+312
-9
lines changed

2 files changed

+312
-9
lines changed

‎interface/core/containers/pair.h‎

Lines changed: 31 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -104,18 +104,24 @@ namespace hud
104104
static_assert(hud::is_nothrow_move_constructible_v<second_type, v_type_t>, "second_type(v_type_t&&) move constructor is throwable. pair is not designed to allow throwable move constructible components");
105105
}
106106

107+
/**
108+
* Piecewise constructor for `pair` using two tuples of arguments to construct each element.
109+
* This constructor forwards the elements of the two tuples into the respective constructors of `first` and `second`.
110+
* Internally, it uses index sequences to unpack the tuple elements and delegates to the other constructor.
111+
*
112+
* @tparam u_type_t Parameter pack for constructing the `first_type`.
113+
* @tparam v_type_t Parameter pack for constructing the `second_type`.
114+
* @param hud::tag_piecewise_construct_t Tag to indicate piecewise construction.
115+
* @param first_tuple Tuple containing arguments to forward to the constructor of `first`.
116+
* @param second_tuple Tuple containing arguments to forward to the constructor of `second`.
117+
*/
107118
template<typename... u_type_t, typename... v_type_t>
108119
requires(hud::is_constructible_v<first_type, u_type_t...> && hud::is_constructible_v<second_type, v_type_t...>)
109120
constexpr pair(hud::tag_piecewise_construct_t, hud::tuple<u_type_t...> first_tuple, hud::tuple<v_type_t...> second_tuple) noexcept
110121
: pair(first_tuple, second_tuple, hud::make_index_sequence_for<u_type_t...> {}, hud::make_index_sequence_for<v_type_t...> {})
111122
{
112-
}
113-
114-
template<typename tuple_first, typename tuple_second, usize... indexes_first, usize... indexes_second>
115-
constexpr pair(tuple_first &first_tuple, tuple_second &second_tuple, hud::index_sequence<indexes_first...>, hud::index_sequence<indexes_second...>) noexcept
116-
: first(hud::get<indexes_first>(hud::move(first_tuple))...)
117-
, second(hud::get<indexes_second>(hud::move(second_tuple))...)
118-
{
123+
static_assert(hud::is_nothrow_constructible_v<first_type, u_type_t...>, "first_type(u_type_t&&...) constructor is throwable. pair is not designed to allow throwable constructible components");
124+
static_assert(hud::is_nothrow_constructible_v<second_type, v_type_t...>, "second_type(v_type_t&&...) constructor is throwable. pair is not designed to allow throwable constructible components");
119125
}
120126

121127
/**
@@ -268,6 +274,24 @@ namespace hud
268274
hud::swap(first, other.first);
269275
hud::swap(second, other.second);
270276
}
277+
278+
private:
279+
/**
280+
* Constructs a `pair` from two tuples by unpacking their elements.
281+
* @tparam tuple_first Type of the first tuple.
282+
* @tparam tuple_second Type of the second tuple.
283+
* @tparam indexes_first Index sequence for elements to extract from the first tuple.
284+
* @tparam indexes_second Index sequence for elements to extract from the second tuple.
285+
* @param first_tuple Reference to the first tuple to move from.
286+
* @param second_tuple Reference to the second tuple to move from.
287+
* @param ... Index sequences used to unpack the tuple elements.
288+
*/
289+
template<typename tuple_first, typename tuple_second, usize... indexes_first, usize... indexes_second>
290+
constexpr pair(tuple_first &first_tuple, tuple_second &second_tuple, hud::index_sequence<indexes_first...>, hud::index_sequence<indexes_second...>) noexcept
291+
: first(hud::get<indexes_first>(hud::move(first_tuple))...)
292+
, second(hud::get<indexes_second>(hud::move(second_tuple))...)
293+
{
294+
}
271295
};
272296

273297
/**

‎test/pair/pair_constructors.cpp‎

Lines changed: 281 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -1761,6 +1761,115 @@ GTEST_TEST(pair, piecewise_constructor_non_trivial_type_same_type)
17611761
}
17621762
}
17631763

1764+
GTEST_TEST(pair, piecewise_constructor_non_trivial_type_different_type)
1765+
{
1766+
// By copy
1767+
{
1768+
const auto test = []()
1769+
{
1770+
using type = hud_test::non_bitwise_type;
1771+
using type2 = hud_test::non_bitwise_type2;
1772+
const type to_copy_0;
1773+
const type to_copy_1;
1774+
hud::pair<type2, type2> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(to_copy_0), hud::forward_as_tuple(to_copy_1)};
1775+
return std::tuple {
1776+
hud::get<0>(pair).constructor_count() == 0, // 0
1777+
hud::get<0>(pair).copy_constructor_count() == 1, // 1
1778+
hud::get<0>(pair).move_constructor_count() == 0, // 2
1779+
hud::get<0>(pair).copy_assign_count() == 0, // 3
1780+
hud::get<0>(pair).move_assign_count() == 0, // 4
1781+
hud::get<1>(pair).constructor_count() == 0, // 5
1782+
hud::get<1>(pair).copy_constructor_count() == 1, // 6
1783+
hud::get<1>(pair).move_constructor_count() == 0, // 7
1784+
hud::get<1>(pair).copy_assign_count() == 0, // 8
1785+
hud::get<1>(pair).move_assign_count() == 0, // 9
1786+
};
1787+
};
1788+
1789+
// Non constant
1790+
{
1791+
const auto result = test();
1792+
hud_assert_true(std::get<0>(result));
1793+
hud_assert_true(std::get<1>(result));
1794+
hud_assert_true(std::get<2>(result));
1795+
hud_assert_true(std::get<3>(result));
1796+
hud_assert_true(std::get<4>(result));
1797+
hud_assert_true(std::get<5>(result));
1798+
hud_assert_true(std::get<6>(result));
1799+
hud_assert_true(std::get<7>(result));
1800+
hud_assert_true(std::get<8>(result));
1801+
hud_assert_true(std::get<9>(result));
1802+
}
1803+
1804+
// Non constant
1805+
{
1806+
constexpr auto result = test();
1807+
hud_assert_true(std::get<0>(result));
1808+
hud_assert_true(std::get<1>(result));
1809+
hud_assert_true(std::get<2>(result));
1810+
hud_assert_true(std::get<3>(result));
1811+
hud_assert_true(std::get<4>(result));
1812+
hud_assert_true(std::get<5>(result));
1813+
hud_assert_true(std::get<6>(result));
1814+
hud_assert_true(std::get<7>(result));
1815+
hud_assert_true(std::get<8>(result));
1816+
hud_assert_true(std::get<9>(result));
1817+
}
1818+
}
1819+
1820+
// By move
1821+
{
1822+
const auto test = []()
1823+
{
1824+
using type = hud_test::non_bitwise_type;
1825+
using type2 = hud_test::non_bitwise_type2;
1826+
hud::pair<type2, type2> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(type {}), hud::forward_as_tuple(type {})};
1827+
return std::tuple {
1828+
hud::get<0>(pair).constructor_count() == 0, // 0
1829+
hud::get<0>(pair).copy_constructor_count() == 0, // 1
1830+
hud::get<0>(pair).move_constructor_count() == 1, // 2
1831+
hud::get<0>(pair).copy_assign_count() == 0, // 3
1832+
hud::get<0>(pair).move_assign_count() == 0, // 4
1833+
hud::get<1>(pair).constructor_count() == 0, // 5
1834+
hud::get<1>(pair).copy_constructor_count() == 0, // 6
1835+
hud::get<1>(pair).move_constructor_count() == 1, // 7
1836+
hud::get<1>(pair).copy_assign_count() == 0, // 8
1837+
hud::get<1>(pair).move_assign_count() == 0, // 9
1838+
};
1839+
};
1840+
1841+
// Non constant
1842+
{
1843+
const auto result = test();
1844+
hud_assert_true(std::get<0>(result));
1845+
hud_assert_true(std::get<1>(result));
1846+
hud_assert_true(std::get<2>(result));
1847+
hud_assert_true(std::get<3>(result));
1848+
hud_assert_true(std::get<4>(result));
1849+
hud_assert_true(std::get<5>(result));
1850+
hud_assert_true(std::get<6>(result));
1851+
hud_assert_true(std::get<7>(result));
1852+
hud_assert_true(std::get<8>(result));
1853+
hud_assert_true(std::get<9>(result));
1854+
}
1855+
1856+
// Non constant
1857+
{
1858+
constexpr auto result = test();
1859+
hud_assert_true(std::get<0>(result));
1860+
hud_assert_true(std::get<1>(result));
1861+
hud_assert_true(std::get<2>(result));
1862+
hud_assert_true(std::get<3>(result));
1863+
hud_assert_true(std::get<4>(result));
1864+
hud_assert_true(std::get<5>(result));
1865+
hud_assert_true(std::get<6>(result));
1866+
hud_assert_true(std::get<7>(result));
1867+
hud_assert_true(std::get<8>(result));
1868+
hud_assert_true(std::get<9>(result));
1869+
}
1870+
}
1871+
}
1872+
17641873
GTEST_TEST(pair, piecewise_constructor_non_trivial_copy_constructible_type_same_type)
17651874
{
17661875
// By copy
@@ -1773,8 +1882,8 @@ GTEST_TEST(pair, piecewise_constructor_non_trivial_copy_constructible_type_same_
17731882
hud::pair<type, type> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(to_copy_0), hud::forward_as_tuple(to_copy_1)};
17741883
return std::tuple {
17751884

1776-
hud::get<0>(pair).copy_constructor_count() == 1, // 1
1777-
hud::get<1>(pair).copy_constructor_count() == 1, // 3
1885+
hud::get<0>(pair).copy_constructor_count() == 1, // 0
1886+
hud::get<1>(pair).copy_constructor_count() == 1, // 1
17781887
};
17791888
};
17801889

@@ -1796,12 +1905,182 @@ GTEST_TEST(pair, piecewise_constructor_non_trivial_copy_constructible_type_same_
17961905

17971906
GTEST_TEST(pair, piecewise_constructor_non_trivial_copy_constructible_type_different_type)
17981907
{
1908+
// By copy
1909+
{
1910+
const auto test = []()
1911+
{
1912+
using type = hud_test::non_bitwise_copy_constructible_type;
1913+
using type2 = hud_test::non_bitwise_copy_constructible_type2;
1914+
const type to_copy_0;
1915+
const type to_copy_1;
1916+
hud::pair<type2, type2> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(to_copy_0), hud::forward_as_tuple(to_copy_1)};
1917+
return std::tuple {
1918+
1919+
hud::get<0>(pair).copy_constructor_count() == 1, // 0
1920+
hud::get<1>(pair).copy_constructor_count() == 1, // 1
1921+
};
1922+
};
1923+
1924+
// Non constant
1925+
{
1926+
const auto result = test();
1927+
hud_assert_true(std::get<0>(result));
1928+
hud_assert_true(std::get<1>(result));
1929+
}
1930+
1931+
// Non constant
1932+
{
1933+
constexpr auto result = test();
1934+
hud_assert_true(std::get<0>(result));
1935+
hud_assert_true(std::get<1>(result));
1936+
}
1937+
}
17991938
}
18001939

18011940
GTEST_TEST(pair, piecewise_constructor_non_trivial_move_constructible_type_same_type)
18021941
{
1942+
// By copy
1943+
{
1944+
const auto test = []()
1945+
{
1946+
using type = hud_test::non_bitwise_move_constructible_type;
1947+
const type to_copy_0;
1948+
const type to_copy_1;
1949+
hud::pair<type, type> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(to_copy_0), hud::forward_as_tuple(to_copy_1)};
1950+
return std::tuple {
1951+
1952+
hud::get<0>(pair).copy_constructor_count() == 1, // 0
1953+
hud::get<1>(pair).copy_constructor_count() == 1, // 1
1954+
hud::get<0>(pair).move_constructor_count() == 0, // 2
1955+
hud::get<1>(pair).move_constructor_count() == 0, // 3
1956+
};
1957+
};
1958+
1959+
// Non constant
1960+
{
1961+
const auto result = test();
1962+
hud_assert_true(std::get<0>(result));
1963+
hud_assert_true(std::get<1>(result));
1964+
hud_assert_true(std::get<2>(result));
1965+
hud_assert_true(std::get<3>(result));
1966+
}
1967+
1968+
// Non constant
1969+
{
1970+
constexpr auto result = test();
1971+
hud_assert_true(std::get<0>(result));
1972+
hud_assert_true(std::get<1>(result));
1973+
hud_assert_true(std::get<2>(result));
1974+
hud_assert_true(std::get<3>(result));
1975+
}
1976+
}
1977+
1978+
// By move
1979+
{
1980+
const auto test = []()
1981+
{
1982+
using type = hud_test::non_bitwise_move_constructible_type;
1983+
hud::pair<type, type> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(type {}), hud::forward_as_tuple(type {})};
1984+
return std::tuple {
1985+
1986+
hud::get<0>(pair).copy_constructor_count() == 0, // 0
1987+
hud::get<1>(pair).copy_constructor_count() == 0, // 1
1988+
hud::get<0>(pair).move_constructor_count() == 1, // 2
1989+
hud::get<1>(pair).move_constructor_count() == 1, // 3
1990+
};
1991+
};
1992+
1993+
// Non constant
1994+
{
1995+
const auto result = test();
1996+
hud_assert_true(std::get<0>(result));
1997+
hud_assert_true(std::get<1>(result));
1998+
hud_assert_true(std::get<2>(result));
1999+
hud_assert_true(std::get<3>(result));
2000+
}
2001+
2002+
// Non constant
2003+
{
2004+
constexpr auto result = test();
2005+
hud_assert_true(std::get<0>(result));
2006+
hud_assert_true(std::get<1>(result));
2007+
hud_assert_true(std::get<2>(result));
2008+
hud_assert_true(std::get<3>(result));
2009+
}
2010+
}
18032011
}
18042012

18052013
GTEST_TEST(pair, piecewise_constructor_non_trivial_move_constructible_type_different_type)
18062014
{
2015+
// By copy
2016+
{
2017+
const auto test = []()
2018+
{
2019+
using type = hud_test::non_bitwise_move_constructible_type;
2020+
using type2 = hud_test::non_bitwise_move_constructible_type2;
2021+
const type to_copy_0;
2022+
const type to_copy_1;
2023+
hud::pair<type2, type2> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(to_copy_0), hud::forward_as_tuple(to_copy_1)};
2024+
return std::tuple {
2025+
2026+
hud::get<0>(pair).copy_constructor_count() == 1, // 0
2027+
hud::get<1>(pair).copy_constructor_count() == 1, // 1
2028+
hud::get<0>(pair).move_constructor_count() == 0, // 2
2029+
hud::get<1>(pair).move_constructor_count() == 0, // 3
2030+
};
2031+
};
2032+
2033+
// Non constant
2034+
{
2035+
const auto result = test();
2036+
hud_assert_true(std::get<0>(result));
2037+
hud_assert_true(std::get<1>(result));
2038+
hud_assert_true(std::get<2>(result));
2039+
hud_assert_true(std::get<3>(result));
2040+
}
2041+
2042+
// Non constant
2043+
{
2044+
constexpr auto result = test();
2045+
hud_assert_true(std::get<0>(result));
2046+
hud_assert_true(std::get<1>(result));
2047+
hud_assert_true(std::get<2>(result));
2048+
hud_assert_true(std::get<3>(result));
2049+
}
2050+
}
2051+
2052+
// By move
2053+
{
2054+
const auto test = []()
2055+
{
2056+
using type = hud_test::non_bitwise_move_constructible_type;
2057+
using type2 = hud_test::non_bitwise_move_constructible_type2;
2058+
hud::pair<type2, type2> pair {hud::tag_piecewise_construct, hud::forward_as_tuple(type {}), hud::forward_as_tuple(type {})};
2059+
return std::tuple {
2060+
2061+
hud::get<0>(pair).copy_constructor_count() == 0, // 0
2062+
hud::get<1>(pair).copy_constructor_count() == 0, // 1
2063+
hud::get<0>(pair).move_constructor_count() == 1, // 2
2064+
hud::get<1>(pair).move_constructor_count() == 1, // 3
2065+
};
2066+
};
2067+
2068+
// Non constant
2069+
{
2070+
const auto result = test();
2071+
hud_assert_true(std::get<0>(result));
2072+
hud_assert_true(std::get<1>(result));
2073+
hud_assert_true(std::get<2>(result));
2074+
hud_assert_true(std::get<3>(result));
2075+
}
2076+
2077+
// Non constant
2078+
{
2079+
constexpr auto result = test();
2080+
hud_assert_true(std::get<0>(result));
2081+
hud_assert_true(std::get<1>(result));
2082+
hud_assert_true(std::get<2>(result));
2083+
hud_assert_true(std::get<3>(result));
2084+
}
2085+
}
18072086
}

0 commit comments

Comments
 (0)