FreeChainXenon/gcc
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Add more testcases for class template argument deduction of maps

Browse source 
This adds additional tests for std::map and std::multimap CTAD. The
tests ensure that deduction works for braced-init-list of value_type
objects, and for pairs of input iterators (with both std::pair<Key, T>
and value_type as the iterator's value_type). This ensures deduction
from value_type still works, as well as the non-value_type cases in LWG
3025.

Similar tests for unordered maps do not work, apparently because the
constructor taking an initializer_list<value_type> is not usable for
deduction, and the deduction guide taking initializer_list<pair<Key, T>>
deduces key_type to be const. I am not addressing that.

	* testsuite/23_containers/map/cons/deduction.cc: Test deduction from
	initializer_list<value_type> and from input iterator ranges.
	* testsuite/23_containers/multimap/cons/deduction.cc: Likewise.

From-SVN: r267518
This commit is contained in:
Jonathan Wakely 2019-01-02 16:30:49 +00:00 • committed by Jonathan Wakely
parent 3f11aa6aa1
commit b3e2dc1ed9
3 changed files with 246 additions and 26 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

4
libstdc++-v3/ChangeLog
View file

@ -1,5 +1,9 @@
2019-01-02 Jonathan Wakely <jwakely@redhat.com>
* testsuite/23_containers/map/cons/deduction.cc: Test deduction from
initializer_list<value_type> and from input iterator ranges.
* testsuite/23_containers/multimap/cons/deduction.cc: Likewise.
* testsuite/experimental/string_view/element_access/char/empty.cc:
Fix year range in copyright header.

137
libstdc++-v3/testsuite/23_containers/map/cons/deduction.cc
View file

@ -3,32 +3,58 @@
#include <map>
#include <testsuite_allocator.h>
#include <testsuite_iterators.h>
using __gnu_test::SimpleAllocator;
using value_type = std::map<int, double>::value_type;
static_assert(std::is_same_v<
decltype(std::map{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
std::less<int>{}, {}}),
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
std::less<int>{}, {}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}}),
std::less<int>{}, {}}),
std::map<int, double>>);
/* This is not deducible, {} could be deduced as _Compare or _Allocator.
static_assert(std::is_same_v<
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
std::map<int, double>>);
*/
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}, {}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<std::pair<const int, double>>{}}),
decltype(std::map{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<std::pair<const int, double>>>>);
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::map{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
void f()
{
@ -39,13 +65,13 @@ void f()
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{},
std::allocator<std::pair<const int, double>>{}}),
std::less<int>{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{}, {}}),
std::less<int>{}, {}}),
std::map<int, double>>);
static_assert(std::is_same_v<
@ -55,14 +81,95 @@ void f()
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
std::allocator<std::pair<const int, double>>{}}),
{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
SimpleAllocator<std::pair<const int, double>>{}}),
{},
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<std::pair<const int, double>>>>);
SimpleAllocator<value_type>>>);
}
using __gnu_test::test_container;
using __gnu_test::input_iterator_wrapper;
void g()
{
value_type array[1];
test_container<value_type, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::map(x.begin(), x.end())),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{}, {}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map(x.begin(), x.end(),
{})),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
}
void h()
{
std::pair<int, double> array[1];
test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::map(x.begin(), x.end())),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
std::less<int>{}, {}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map(x.begin(), x.end(),
{})),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::map<int, double>>);
static_assert(std::is_same_v<
decltype(std::map{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::map<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
}

131
libstdc++-v3/testsuite/23_containers/multimap/cons/deduction.cc
View file

@ -3,32 +3,60 @@
#include <map>
#include <testsuite_allocator.h>
#include <testsuite_iterators.h>
using __gnu_test::SimpleAllocator;
using value_type = std::multimap<int, double>::value_type;
static_assert(std::is_same_v<
decltype(std::multimap{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
std::less<int>{}, {}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
std::less<int>{}, {}}),
std::multimap<int, double>>);
/* This is not deducible, {} could be deduced as _Compare or _Allocator.
static_assert(std::is_same_v<
decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}}),
std::multimap<int, double>>);
*/
static_assert(std::is_same_v<
decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<std::pair<const int, double>>{}}),
decltype(std::multimap{{value_type{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<value_type>{}}),
std::multimap<int, double, std::less<int>,
SimpleAllocator<std::pair<const int, double>>>>);
SimpleAllocator<value_type>>>);
static_assert(std::is_same_v<
decltype(std::multimap{{std::pair{1, 2.0}, {2, 3.0}, {3, 4.0}},
{}, SimpleAllocator<value_type>{}}),
std::multimap<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
void f()
{
@ -39,30 +67,111 @@ void f()
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{},
std::allocator<std::pair<const int, double>>{}}),
std::less<int>{},
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{}, {}}),
std::less<int>{}, {}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap(x.begin(), x.end(),
{})),
{})),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
std::allocator<std::pair<const int, double>>{}}),
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
SimpleAllocator<std::pair<const int, double>>{}}),
{},
SimpleAllocator<value_type>{}}),
std::multimap<int, double, std::less<int>,
SimpleAllocator<std::pair<const int, double>>>>);
SimpleAllocator<value_type>>>);
}
using __gnu_test::test_container;
using __gnu_test::input_iterator_wrapper;
void g()
{
value_type array[1];
test_container<value_type, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::multimap(x.begin(), x.end())),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{}, {}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap(x.begin(), x.end(),
{})),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::multimap<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
}
void h()
{
std::pair<int, double> array[1];
test_container<std::pair<int, double>, input_iterator_wrapper> x(array);
static_assert(std::is_same_v<
decltype(std::multimap(x.begin(), x.end())),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{},
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
std::less<int>{}, {}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap(x.begin(), x.end(),
{})),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
std::allocator<value_type>{}}),
std::multimap<int, double>>);
static_assert(std::is_same_v<
decltype(std::multimap{x.begin(), x.end(),
{},
SimpleAllocator<value_type>{}}),
std::multimap<int, double, std::less<int>,
SimpleAllocator<value_type>>>);
}