LineageOS/android_external_libcxx
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[libcxx] Remove dynarray

Browse Source 
Summary:
std::dynarray had been proposed for C++14, but it was pulled out from C++14
and there are no plans to standardize it anymore.

Reviewers: mclow.lists, EricWF

Subscribers: mgorny, christof, jkorous, dexonsmith, arphaman, libcxx-commits

Differential Revision: https://reviews.llvm.org/D54801

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@347783 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Louis Dionne
2018-11-28 18:02:00 +00:00
parent 97c03fb705
commit 581671fd26
21 changed files with 4 additions and 1152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
test/libcxx/double_include.sh.cpp
View File

@@ -145,7 +145,6 @@
#include <experimental/coroutine>
#endif
#include <experimental/deque>
#include <experimental/dynarray>
#include <experimental/filesystem>
#include <experimental/forward_list>
#include <experimental/functional>

83
test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/alloc.pass.cpp
View File

@@ -1,83 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.cons
// template <class Alloc>
// dynarray(size_type c, const Alloc& alloc);
// template <class Alloc>
// dynarray(size_type c, const T& v, const Alloc& alloc);
// template <class Alloc>
// dynarray(const dynarray& d, const Alloc& alloc);
// template <class Alloc>
// dynarray(initializer_list<T>, const Alloc& alloc);
// ~dynarray();
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
#include "test_allocator.h"
using std::experimental::dynarray;
template <class T, class Allocator>
void check_allocator ( const dynarray<T> &dyn, const Allocator &alloc ) {
for ( int i = 0; i < dyn.size (); ++i )
assert ( dyn[i].get_allocator() == alloc );
}
template <class T, class Allocator>
void test ( const std::initializer_list<T> &vals, const Allocator &alloc ) {
typedef dynarray<T> dynA;
dynA d1 ( vals, alloc );
assert ( d1.size () == vals.size() );
assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
check_allocator ( d1, alloc );
}
template <class T, class Allocator>
void test ( const T &val, const Allocator &alloc1, const Allocator &alloc2 ) {
typedef dynarray<T> dynA;
dynA d1 ( 4, alloc1 );
assert ( d1.size () == 4 );
assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } ));
check_allocator ( d1, alloc1 );
dynA d2 ( 7, val, alloc1 );
assert ( d2.size () == 7 );
assert ( std::all_of ( d2.begin (), d2.end (), [&val]( const T &item ){ return item == val; } ));
check_allocator ( d2, alloc1 );
dynA d3 ( d2, alloc2 );
assert ( d3.size () == 7 );
assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
check_allocator ( d3, alloc2 );
}
int main()
{
// This test is waiting on the resolution of LWG issue #2235
// typedef test_allocator<char> Alloc;
// typedef std::basic_string<char, std::char_traits<char>, Alloc> nstr;
//
// test ( nstr("fourteen"), Alloc(3), Alloc(4) );
// test ( { nstr("1"), nstr("1"), nstr("2"), nstr("3"), nstr("5"), nstr("8")}, Alloc(6));
}

102
test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default.pass.cpp
View File

@@ -1,102 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability=macosx10.12
// XFAIL: availability=macosx10.11
// XFAIL: availability=macosx10.10
// XFAIL: availability=macosx10.9
// XFAIL: availability=macosx10.8
// XFAIL: availability=macosx10.7
// dynarray.cons
// explicit dynarray(size_type c);
// dynarray(size_type c, const T& v);
// dynarray(initializer_list<T>);
// dynarray(const dynarray& d);
// ~dynarray();
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <limits>
#include <new>
#include <string>
#include "test_macros.h"
using std::experimental::dynarray;
template <class T>
void testInitList( const std::initializer_list<T> &vals ) {
typedef dynarray<T> dynA;
dynA d1 ( vals );
assert ( d1.size () == vals.size() );
assert ( std::equal ( vals.begin (), vals.end (), d1.begin (), d1.end ()));
}
template <class T>
void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
typedef dynarray<T> dynA;
dynA d1 ( 4 );
assert ( d1.size () == 4 );
if (!DefaultValueIsIndeterminate) {
assert ( std::all_of ( d1.begin (), d1.end (), []( const T &item ){ return item == T(); } ));
}
dynA d2 ( 7, val );
assert ( d2.size () == 7 );
assert ( std::all_of ( d2.begin (), d2.end (), [&val]( const T &item ){ return item == val; } ));
dynA d3 ( d2 );
assert ( d3.size () == 7 );
assert ( std::all_of ( d3.begin (), d3.end (), [&val]( const T &item ){ return item == val; } ));
}
#ifndef TEST_HAS_NO_EXCEPTIONS
void test_bad_length () {
try { dynarray<int> ( std::numeric_limits<size_t>::max() / sizeof ( int ) + 1 ); }
catch ( std::bad_array_length & ) { return ; }
catch (...) { assert(false); }
assert ( false );
}
#endif
int main()
{
test<int> ( 14, /* DefaultValueIsIndeterminate */ true ); // ints don't get default initialized
test<long> ( 0, true);
test<double> ( 14.0, true );
test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" );
testInitList( { 1, 1, 2, 3, 5, 8 } );
testInitList( { 1., 1., 2., 3., 5., 8. } );
testInitList( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} );
// Make sure we don't pick up the Allocator version here
dynarray<long> d1 ( 20, 3 );
assert ( d1.size() == 20 );
assert ( std::all_of ( d1.begin (), d1.end (), []( long item ){ return item == 3L; } ));
#ifndef TEST_HAS_NO_EXCEPTIONS
test_bad_length ();
#endif
}

35
test/libcxx/experimental/containers/sequences/dynarray/dynarray.cons/default_throws_bad_alloc.pass.cpp
View File

@@ -1,35 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: libcpp-no-exceptions
// XFAIL: availability
// dynarray.cons
// explicit dynarray(size_type c);
// UNSUPPORTED: c++98, c++03, c++11
// The sanitizers replace new/delete with versions that do not throw bad_alloc.
// UNSUPPORTED: sanitizer-new-delete
#include <experimental/dynarray>
#include <limits>
#include <new>
#include <cassert>
using std::experimental::dynarray;
int main() {
try { dynarray<int>((std::numeric_limits<size_t>::max() / sizeof(int)) - 1); }
catch (std::bad_alloc &) { return 0; }
catch (...) { assert(false); }
assert(false);
}

69
test/libcxx/experimental/containers/sequences/dynarray/dynarray.data/default.pass.cpp
View File

@@ -1,69 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.data
// T* data() noexcept;
// const T* data() const noexcept;
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_test_const(const dynarray<T> &dyn, bool CheckEquals = true) {
const T *data = dyn.data ();
assert ( data != NULL );
if (CheckEquals) {
assert ( std::equal ( dyn.begin(), dyn.end(), data ));
}
}
template <class T>
void dyn_test( dynarray<T> &dyn, bool CheckEquals = true) {
T *data = dyn.data ();
assert ( data != NULL );
if (CheckEquals) {
assert ( std::equal ( dyn.begin(), dyn.end(), data ));
}
}
template <class T>
void test(const T &val, bool DefaultValueIsIndeterminate = false) {
typedef dynarray<T> dynA;
const bool CheckDefaultValues = !DefaultValueIsIndeterminate;
dynA d1(4);
dyn_test(d1, CheckDefaultValues);
dyn_test_const(d1, CheckDefaultValues);
dynA d2 (7, val);
dyn_test ( d2 );
dyn_test_const ( d2 );
}
int main()
{
test<int>(14, /* DefaultValueIsIndeterminate */ true);
test<double>(14.0, true);
test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" );
}

47
test/libcxx/experimental/containers/sequences/dynarray/dynarray.mutate/default.pass.cpp
View File

@@ -1,47 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.data
// void fill(const T& v);
// const T* data() const noexcept;
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void test ( const T &val ) {
typedef dynarray<T> dynA;
dynA d1 ( 4 );
d1.fill ( val );
assert ( std::all_of ( d1.begin (), d1.end (),
[&val]( const T &item ){ return item == val; } ));
}
int main()
{
test<int> ( 14 );
test<double> ( 14.0 );
test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" );
}

94
test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/at.pass.cpp
View File

@@ -1,94 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// UNSUPPORTED: libcpp-no-exceptions
// XFAIL: availability
// dynarray.overview
// const_reference at(size_type n) const;
// reference at(size_type n);
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_at_fail ( dynarray<T> &dyn, size_t sz ) {
try { dyn.at (sz); }
catch (const std::out_of_range &) { return; }
assert ( false );
}
template <class T>
void dyn_at_fail_const ( const dynarray<T> &dyn, size_t sz ) {
try { dyn.at (sz); }
catch (const std::out_of_range &) { return; }
assert ( false );
}
template <class T>
void dyn_test_const ( const dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
const T *data = dyn.data ();
auto it = vals.begin ();
for ( size_t i = 0; i < dyn.size(); ++i, ++it ) {
assert ( data + i == &dyn.at(i));
assert ( *it == dyn.at(i));
}
dyn_at_fail_const ( dyn, dyn.size ());
dyn_at_fail_const ( dyn, 2*dyn.size ());
dyn_at_fail_const ( dyn, size_t (-1));
}
template <class T>
void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
T *data = dyn.data ();
auto it = vals.begin ();
for ( size_t i = 0; i < dyn.size(); ++i, ++it ) {
assert ( data + i == &dyn.at(i));
assert ( *it == dyn.at(i));
}
dyn_at_fail ( dyn, dyn.size ());
dyn_at_fail ( dyn, 2*dyn.size ());
dyn_at_fail ( dyn, size_t (-1));
}
template <class T>
void test ( std::initializer_list<T> vals ) {
typedef dynarray<T> dynA;
dynA d1 ( vals );
dyn_test ( d1, vals );
dyn_test_const ( d1, vals );
}
int main()
{
test ( { 1, 1, 2, 3, 5, 8 } );
test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} );
test<int> ( {} );
test<std::complex<double>> ( {} );
test<std::string> ( {} );
}

110
test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/begin_end.pass.cpp
View File

@@ -1,110 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.overview
// iterator begin() noexcept;
// const_iterator begin() const noexcept;
// const_iterator cbegin() const noexcept;
// iterator end() noexcept;
// const_iterator end() const noexcept;
// const_iterator cend() const noexcept;
//
// reverse_iterator rbegin() noexcept;
// const_reverse_iterator rbegin() const noexcept;
// const_reverse_iterator crbegin() const noexcept;
// reverse_iterator rend() noexcept;
// const_reverse_iterator rend() const noexcept;
// const_reverse_iterator crend() const noexcept;
#include <__config>
#include <experimental/dynarray>
#include <cstddef>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_test_const ( const dynarray<T> &dyn ) {
const T *data = dyn.data ();
assert ( data == &*dyn.begin ());
assert ( data == &*dyn.cbegin ());
assert ( data + dyn.size() - 1 == &*dyn.rbegin ());
assert ( data + dyn.size() - 1 == &*dyn.crbegin ());
std::ptrdiff_t ds = static_cast<std::ptrdiff_t>(dyn.size());
assert (ds == std::distance ( dyn.begin(), dyn.end()));
assert (ds == std::distance ( dyn.cbegin(), dyn.cend()));
assert (ds == std::distance ( dyn.rbegin(), dyn.rend()));
assert (ds == std::distance ( dyn.crbegin(), dyn.crend()));
assert ( dyn.begin () == dyn.cbegin ());
assert ( &*dyn.begin () == &*dyn.cbegin ());
assert ( dyn.rbegin () == dyn.crbegin ());
assert ( &*dyn.rbegin () == &*dyn.crbegin ());
assert ( dyn.end () == dyn.cend ());
assert ( dyn.rend () == dyn.crend ());
}
template <class T>
void dyn_test ( dynarray<T> &dyn ) {
T *data = dyn.data ();
assert ( data == &*dyn.begin ());
assert ( data == &*dyn.cbegin ());
assert ( data + dyn.size() - 1 == &*dyn.rbegin ());
assert ( data + dyn.size() - 1 == &*dyn.crbegin ());
std::ptrdiff_t ds = static_cast<std::ptrdiff_t>(dyn.size());
assert (ds == std::distance ( dyn.begin(), dyn.end()));
assert (ds == std::distance ( dyn.cbegin(), dyn.cend()));
assert (ds == std::distance ( dyn.rbegin(), dyn.rend()));
assert (ds == std::distance ( dyn.crbegin(), dyn.crend()));
assert ( dyn.begin () == dyn.cbegin ());
assert ( &*dyn.begin () == &*dyn.cbegin ());
assert ( dyn.rbegin () == dyn.crbegin ());
assert ( &*dyn.rbegin () == &*dyn.crbegin ());
assert ( dyn.end () == dyn.cend ());
assert ( dyn.rend () == dyn.crend ());
}
template <class T>
void test ( const T &val ) {
typedef dynarray<T> dynA;
dynA d1 ( 4 );
dyn_test ( d1 );
dyn_test_const ( d1 );
dynA d2 ( 7, val );
dyn_test ( d2 );
dyn_test_const ( d2 );
}
int main()
{
test<int> ( 14 );
test<double> ( 14.0 );
test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" );
}

56
test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/capacity.pass.cpp
View File

@@ -1,56 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.overview
// size_type size() const noexcept;
// size_type max_size() const noexcept;
// bool empty() const noexcept;
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_test ( const dynarray<T> &dyn, size_t sz ) {
assert ( dyn.size () == sz );
assert ( dyn.max_size () == sz );
assert ( dyn.empty () == ( sz == 0 ));
}
template <class T>
void test ( std::initializer_list<T> vals ) {
typedef dynarray<T> dynA;
dynA d1 ( vals );
dyn_test ( d1, vals.size ());
}
int main()
{
test ( { 1, 1, 2, 3, 5, 8 } );
test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} );
test<int> ( {} );
test<std::complex<double>> ( {} );
test<std::string> ( {} );
}

74
test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/front_back.pass.cpp
View File

@@ -1,74 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.overview
// reference front();
// const_reference front() const;
// reference back();
// const_reference back() const;
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_test_const ( const dynarray<T> &dyn, bool CheckValues = true ) {
const T *data = dyn.data ();
assert(data == &dyn.front());
assert((data + dyn.size() - 1) == &dyn.back());
if (CheckValues) {
assert ( *data == dyn.front ());
assert ( *(data + dyn.size() - 1 ) == dyn.back ());
}
}
template <class T>
void dyn_test ( dynarray<T> &dyn, bool CheckValues = true ) {
T *data = dyn.data ();
assert(data == &dyn.front());
assert((data + dyn.size() - 1) == &dyn.back());
if (CheckValues) {
assert ( *data == dyn.front ());
assert ( *(data + dyn.size() - 1 ) == dyn.back ());
}
}
template <class T>
void test ( const T &val, bool DefaultValueIsIndeterminate = false) {
typedef dynarray<T> dynA;
const bool CheckDefaultValues = ! DefaultValueIsIndeterminate;
dynA d1 ( 4 );
dyn_test ( d1, CheckDefaultValues );
dyn_test_const ( d1, CheckDefaultValues );
dynA d2 ( 7, val );
dyn_test ( d2 );
dyn_test_const ( d2 );
}
int main()
{
test<int> ( 14, /* DefaultValueIsIndeterminate */ true);
test<double> ( 14.0, true );
test<std::complex<double>> ( std::complex<double> ( 14, 0 ));
test<std::string> ( "fourteen" );
}

76
test/libcxx/experimental/containers/sequences/dynarray/dynarray.overview/indexing.pass.cpp
View File

@@ -1,76 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability=macosx10.12
// XFAIL: availability=macosx10.11
// XFAIL: availability=macosx10.10
// XFAIL: availability=macosx10.9
// XFAIL: availability=macosx10.8
// XFAIL: availability=macosx10.7
// dynarray.overview
// const_reference at(size_type n) const;
// reference at(size_type n);
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void dyn_test_const ( const dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
const T *data = dyn.data ();
auto it = vals.begin ();
for ( size_t i = 0; i < dyn.size(); ++i, ++it ) {
assert ( data + i == &dyn[i]);
assert ( *it == dyn[i]);
}
}
template <class T>
void dyn_test ( dynarray<T> &dyn, const std::initializer_list<T> &vals ) {
T *data = dyn.data ();
auto it = vals.begin ();
for ( size_t i = 0; i < dyn.size(); ++i, ++it ) {
assert ( data + i == &dyn[i]);
assert ( *it == dyn[i]);
}
}
template <class T>
void test ( std::initializer_list<T> vals ) {
typedef dynarray<T> dynA;
dynA d1 ( vals );
dyn_test ( d1, vals );
dyn_test_const ( d1, vals );
}
int main()
{
test ( { 1, 1, 2, 3, 5, 8 } );
test ( { 1., 1., 2., 3., 5., 8. } );
test ( { std::string("1"), std::string("1"), std::string("2"), std::string("3"),
std::string("5"), std::string("8")} );
test<int> ( {} );
test<std::complex<double>> ( {} );
test<std::string> ( {} );
}

28
test/libcxx/experimental/containers/sequences/dynarray/dynarray.traits/default.pass.cpp
View File

@@ -1,28 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// dynarray.data
// template <class Type, class Alloc>
// struct uses_allocator<dynarray<Type>, Alloc> : true_type { };
#include <__config>
#include <experimental/dynarray>
#include "test_allocator.h"
using std::experimental::dynarray;
int main()
{
static_assert ( std::uses_allocator<dynarray<int>, test_allocator<int>>::value, "" );
}

48
test/libcxx/experimental/containers/sequences/dynarray/dynarray.zero/default.pass.cpp
View File

@@ -1,48 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
// UNSUPPORTED: c++98, c++03, c++11
// XFAIL: availability
// dynarray.zero
// dynarray shall provide support for the special case of construction with a size of zero.
// In the case that the size is zero, begin() == end() == unique value.
// The return value of data() is unspecified.
// The effect of calling front() or back() for a zero-sized dynarray is undefined.
#include <__config>
#include <experimental/dynarray>
#include <cassert>
#include <algorithm>
#include <complex>
#include <string>
using std::experimental::dynarray;
template <class T>
void test ( ) {
typedef dynarray<T> dynA;
dynA d1 ( 0 );
assert ( d1.size() == 0 );
assert ( d1.begin() == d1.end ());
}
int main()
{
test<int> ();
test<double> ();
test<std::complex<double>> ();
test<std::string> ();
}

3
test/libcxx/experimental/containers/sequences/dynarray/lit.local.cfg
View File

@@ -1,3 +0,0 @@
if ('availability' in config.available_features
and not 'libcpp-no-exceptions' in config.available_features):
config.unsupported = True

12
test/libcxx/experimental/containers/sequences/dynarray/nothing_to_do.pass.cpp
View File

@@ -1,12 +0,0 @@
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
int main()
{
}

2
test/libcxx/min_max_macros.sh.cpp
View File

@@ -241,8 +241,6 @@ TEST_MACROS();
TEST_MACROS();
#include <experimental/deque>
TEST_MACROS();
#include <experimental/dynarray>
TEST_MACROS();
#include <experimental/filesystem>
TEST_MACROS();
#include <experimental/forward_list>