generic-library/cxx
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Move test into test/std subdirectory.

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@224658 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Eric Fiselier
2014-12-20 01:40:03 +00:00
parent 669a8a5a19
commit a90c6dd460
4817 changed files with 13 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

59
test/std/language.support/support.exception/except.nested/assign.pass.cpp Normal file
View File

@@ -0,0 +1,59 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// nested_exception& operator=(const nested_exception&) throw() = default;
#include <exception>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
int main()
{
{
std::nested_exception e0;
std::nested_exception e;
e = e0;
assert(e.nested_ptr() == nullptr);
}
{
try
{
throw A(2);
assert(false);
}
catch (const A&)
{
std::nested_exception e0;
std::nested_exception e;
e = e0;
assert(e.nested_ptr() != nullptr);
try
{
rethrow_exception(e.nested_ptr());
assert(false);
}
catch (const A& a)
{
assert(a == A(2));
}
}
}
}

57
test/std/language.support/support.exception/except.nested/ctor_copy.pass.cpp Normal file
View File

@@ -0,0 +1,57 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// nested_exception(const nested_exception&) throw() = default;
#include <exception>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
int main()
{
{
std::nested_exception e0;
std::nested_exception e = e0;
assert(e.nested_ptr() == nullptr);
}
{
try
{
throw A(2);
assert(false);
}
catch (const A&)
{
std::nested_exception e0;
std::nested_exception e = e0;
assert(e.nested_ptr() != nullptr);
try
{
rethrow_exception(e.nested_ptr());
assert(false);
}
catch (const A& a)
{
assert(a == A(2));
}
}
}
}

55
test/std/language.support/support.exception/except.nested/ctor_default.pass.cpp Normal file
View File

@@ -0,0 +1,55 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// nested_exception() throw();
#include <exception>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
int main()
{
{
std::nested_exception e;
assert(e.nested_ptr() == nullptr);
}
{
try
{
throw A(2);
assert(false);
}
catch (const A&)
{
std::nested_exception e;
assert(e.nested_ptr() != nullptr);
try
{
rethrow_exception(e.nested_ptr());
assert(false);
}
catch (const A& a)
{
assert(a == A(2));
}
}
}
}

89
test/std/language.support/support.exception/except.nested/rethrow_if_nested.pass.cpp Normal file
View File

@@ -0,0 +1,89 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// template <class E> void rethrow_if_nested(const E& e);
#include <exception>
#include <cstdlib>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
virtual ~A() _NOEXCEPT {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
class B
: public std::nested_exception,
public A
{
public:
explicit B(int data) : A(data) {}
B(const B& b) : A(b) {}
};
int main()
{
{
try
{
A a(3);
std::rethrow_if_nested(a);
assert(true);
}
catch (...)
{
assert(false);
}
}
{
try
{
throw B(5);
}
catch (const B& b)
{
try
{
throw b;
}
catch (const A& a)
{
try
{
std::rethrow_if_nested(a);
assert(false);
}
catch (const B& b)
{
assert(b == B(5));
}
}
}
}
{
try
{
std::rethrow_if_nested(1);
assert(true);
}
catch (...)
{
assert(false);
}
}
}

70
test/std/language.support/support.exception/except.nested/rethrow_nested.pass.cpp Normal file
View File

@@ -0,0 +1,70 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// void rethrow_nested [[noreturn]] () const;
#include <exception>
#include <cstdlib>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
void go_quietly()
{
std::exit(0);
}
int main()
{
{
try
{
throw A(2);
assert(false);
}
catch (const A&)
{
const std::nested_exception e;
assert(e.nested_ptr() != nullptr);
try
{
e.rethrow_nested();
assert(false);
}
catch (const A& a)
{
assert(a == A(2));
}
}
}
{
try
{
std::set_terminate(go_quietly);
const std::nested_exception e;
e.rethrow_nested();
assert(false);
}
catch (...)
{
assert(false);
}
}
}

103
test/std/language.support/support.exception/except.nested/throw_with_nested.pass.cpp Normal file
View File

@@ -0,0 +1,103 @@
//===----------------------------------------------------------------------===//
//
// 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.
//
//===----------------------------------------------------------------------===//
// <exception>
// class nested_exception;
// template<class T> void throw_with_nested [[noreturn]] (T&& t);
#include <exception>
#include <cstdlib>
#include <cassert>
class A
{
int data_;
public:
explicit A(int data) : data_(data) {}
friend bool operator==(const A& x, const A& y) {return x.data_ == y.data_;}
};
class B
: public std::nested_exception
{
int data_;
public:
explicit B(int data) : data_(data) {}
friend bool operator==(const B& x, const B& y) {return x.data_ == y.data_;}
};
int main()
{
{
try
{
A a(3);
std::throw_with_nested(a);
assert(false);
}
catch (const A& a)
{
assert(a == A(3));
}
}
{
try
{
A a(4);
std::throw_with_nested(a);
assert(false);
}
catch (const std::nested_exception& e)
{
assert(e.nested_ptr() == nullptr);
}
}
{
try
{
B b(5);
std::throw_with_nested(b);
assert(false);
}
catch (const B& b)
{
assert(b == B(5));
}
}
{
try
{
B b(6);
std::throw_with_nested(b);
assert(false);
}
catch (const std::nested_exception& e)
{
assert(e.nested_ptr() == nullptr);
const B& b = dynamic_cast<const B&>(e);
assert(b == B(6));
}
}
{
try
{
int i = 7;
std::throw_with_nested(i);
assert(false);
}
catch (int i)
{
assert(i == 7);
}
}
}