diff options
author | Howard Hinnant <hhinnant@apple.com> | 2012-01-31 23:52:20 +0000 |
---|---|---|
committer | Howard Hinnant <hhinnant@apple.com> | 2012-01-31 23:52:20 +0000 |
commit | 372e2f4bd4c175b62b65815b604460e491455984 (patch) | |
tree | ac1aca99367ac948c33b08a91754eadf95cb57a7 /libcxxabi/test | |
parent | a2147ce313a1ed42fdf0a4cb1d122690a781cacb (diff) | |
download | bcm5719-llvm-372e2f4bd4c175b62b65815b604460e491455984.tar.gz bcm5719-llvm-372e2f4bd4c175b62b65815b604460e491455984.zip |
More test cases concentrating on catching class types.
llvm-svn: 149453
Diffstat (limited to 'libcxxabi/test')
-rw-r--r-- | libcxxabi/test/catch_class_01.cpp | 58 | ||||
-rw-r--r-- | libcxxabi/test/catch_class_02.cpp | 83 | ||||
-rw-r--r-- | libcxxabi/test/catch_class_03.cpp | 190 | ||||
-rw-r--r-- | libcxxabi/test/catch_class_04.cpp | 213 | ||||
-rw-r--r-- | libcxxabi/test/dynamic_cast_stress.cpp | 4 |
5 files changed, 546 insertions, 2 deletions
diff --git a/libcxxabi/test/catch_class_01.cpp b/libcxxabi/test/catch_class_01.cpp new file mode 100644 index 00000000000..fb728b5252b --- /dev/null +++ b/libcxxabi/test/catch_class_01.cpp @@ -0,0 +1,58 @@ +//===---------------------- catch_class_01.cpp ----------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +#include <exception> +#include <stdlib.h> +#include <assert.h> + +struct A +{ + static int count; + int id_; + explicit A(int id) : id_(id) {count++;} + A(const A& a) : id_(a.id_) {count++;} + ~A() {count--;} +}; + +int A::count = 0; + +void f1() +{ + throw A(3); +} + +void f2() +{ + try + { + assert(A::count == 0); + f1(); + } + catch (A a) + { + assert(A::count != 0); + assert(a.id_ == 3); + throw; + } +} + +int main() +{ + try + { + f2(); + assert(false); + } + catch (const A& a) + { + assert(A::count != 0); + assert(a.id_ == 3); + } + assert(A::count == 0); +} diff --git a/libcxxabi/test/catch_class_02.cpp b/libcxxabi/test/catch_class_02.cpp new file mode 100644 index 00000000000..e1370363d55 --- /dev/null +++ b/libcxxabi/test/catch_class_02.cpp @@ -0,0 +1,83 @@ +//===---------------------- catch_class_02.cpp ----------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +#include <exception> +#include <stdlib.h> +#include <assert.h> + +struct B +{ + static int count; + int id_; + explicit B(int id) : id_(id) {count++;} + B(const B& a) : id_(a.id_) {count++;} + ~B() {count--;} +}; + +int B::count = 0; + +struct A + : B +{ + static int count; + int id_; + explicit A(int id) : B(id-1), id_(id) {count++;} + A(const A& a) : B(a.id_-1), id_(a.id_) {count++;} + ~A() {count--;} +}; + +int A::count = 0; + +void f1() +{ + assert(A::count == 0); + assert(B::count == 0); + A a(3); + assert(A::count == 1); + assert(B::count == 1); + throw a; + assert(false); +} + +void f2() +{ + try + { + assert(A::count == 0); + f1(); + assert(false); + } + catch (A a) + { + assert(A::count != 0); + assert(B::count != 0); + assert(a.id_ == 3); + throw; + } + catch (B b) + { + assert(false); + } +} + +int main() +{ + try + { + f2(); + assert(false); + } + catch (const B& b) + { + assert(B::count != 0); + assert(b.id_ == 2); + } + assert(A::count == 0); + assert(B::count == 0); +} diff --git a/libcxxabi/test/catch_class_03.cpp b/libcxxabi/test/catch_class_03.cpp new file mode 100644 index 00000000000..ad0c9ad8d79 --- /dev/null +++ b/libcxxabi/test/catch_class_03.cpp @@ -0,0 +1,190 @@ +//===---------------------- catch_class_03.cpp ----------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +/* + This test checks that adjustedPtr is correct as there exist offsets in this + object for the various subobjects, all of which have a unique id_ to + check against. +*/ + +#include <exception> +#include <stdlib.h> +#include <assert.h> + +struct B +{ + static int count; + int id_; + explicit B(int id) : id_(id) {count++;} + B(const B& a) : id_(a.id_) {count++;} + ~B() {count--;} +}; + +int B::count = 0; + +struct C1 + : B +{ + static int count; + int id_; + explicit C1(int id) : B(id-2), id_(id) {count++;} + C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;} + ~C1() {count--;} +}; + +int C1::count = 0; + +struct C2 + : B +{ + static int count; + int id_; + explicit C2(int id) : B(id-2), id_(id) {count++;} + C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;} + ~C2() {count--;} +}; + +int C2::count = 0; + +struct A + : C1, C2 +{ + static int count; + int id_; + explicit A(int id) : C1(id-1), C2(id-2), id_(id) {count++;} + A(const A& a) : C1(a.id_-1), C2(a.id_-2), id_(a.id_) {count++;} + ~A() {count--;} +}; + +int A::count = 0; + +void f1() +{ + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + A a(5); + assert(A::count == 1); + assert(C1::count == 1); + assert(C2::count == 1); + assert(B::count == 2); + + assert(a.id_ == 5); + assert(static_cast<C1&>(a).id_ == 4); + assert(static_cast<C2&>(a).id_ == 3); + assert(static_cast<B&>(static_cast<C1&>(a)).id_ == 2); + assert(static_cast<B&>(static_cast<C2&>(a)).id_ == 1); + throw a; + assert(false); +} + +void f2() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f1(); + assert(false); + } + catch (const A& a) // can catch A + { + assert(a.id_ == 5); + assert(static_cast<const C1&>(a).id_ == 4); + assert(static_cast<const C2&>(a).id_ == 3); + assert(static_cast<const B&>(static_cast<const C1&>(a)).id_ == 2); + assert(static_cast<const B&>(static_cast<const C2&>(a)).id_ == 1); + throw; + } + catch (const C1&) + { + assert(false); + } + catch (const C2&) + { + assert(false); + } + catch (const B&) + { + assert(false); + } +} + +void f3() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f2(); + assert(false); + } + catch (const B& a) // can not catch B (ambiguous base) + { + assert(false); + } + catch (const C1& c1) // can catch C1 + { + assert(c1.id_ == 4); + assert(static_cast<const B&>(c1).id_ == 2); + throw; + } + catch (const C2&) + { + assert(false); + } +} + +void f4() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f3(); + assert(false); + } + catch (const B& a) // can not catch B (ambiguous base) + { + assert(false); + } + catch (const C2& c2) // can catch C2 + { + assert(c2.id_ == 3); + assert(static_cast<const B&>(c2).id_ == 1); + throw; + } + catch (const C1&) + { + assert(false); + } +} + +int main() +{ + try + { + f4(); + assert(false); + } + catch (...) + { + } + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); +} diff --git a/libcxxabi/test/catch_class_04.cpp b/libcxxabi/test/catch_class_04.cpp new file mode 100644 index 00000000000..c0e71704901 --- /dev/null +++ b/libcxxabi/test/catch_class_04.cpp @@ -0,0 +1,213 @@ +//===---------------------- catch_class_04.cpp ----------------------------===// +// +// 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. +// +//===----------------------------------------------------------------------===// + +/* + This test checks that adjustedPtr is correct as there exist offsets in this + object for the various subobjects, all of which have a unique id_ to + check against. It also checks that virtual bases work properly +*/ + +#include <exception> +#include <stdlib.h> +#include <assert.h> + +struct B +{ + static int count; + int id_; + explicit B(int id) : id_(id) {count++;} + B(const B& a) : id_(a.id_) {count++;} + ~B() {count--;} +}; + +int B::count = 0; + +struct C1 + : virtual B +{ + static int count; + int id_; + explicit C1(int id) : B(id-2), id_(id) {count++;} + C1(const C1& a) : B(a.id_-2), id_(a.id_) {count++;} + ~C1() {count--;} +}; + +int C1::count = 0; + +struct C2 + : virtual private B +{ + static int count; + int id_; + explicit C2(int id) : B(id-2), id_(id) {count++;} + C2(const C2& a) : B(a.id_-2), id_(a.id_) {count++;} + ~C2() {count--;} +}; + +int C2::count = 0; + +struct A + : C1, C2 +{ + static int count; + int id_; + explicit A(int id) : C1(id-1), C2(id-2), B(id+3), id_(id) {count++;} + A(const A& a) : C1(a.id_-1), C2(a.id_-2), B(a.id_+3), id_(a.id_) {count++;} + ~A() {count--;} +}; + +int A::count = 0; + +void f1() +{ + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + A a(5); + assert(A::count == 1); + assert(C1::count == 1); + assert(C2::count == 1); + assert(B::count == 1); + + assert(a.id_ == 5); + assert(static_cast<C1&>(a).id_ == 4); + assert(static_cast<C2&>(a).id_ == 3); + assert(static_cast<B&>(a).id_ == 8); + throw a; + assert(false); +} + +void f2() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f1(); + assert(false); + } + catch (const A& a) // can catch A + { + assert(a.id_ == 5); + assert(static_cast<const C1&>(a).id_ == 4); + assert(static_cast<const C2&>(a).id_ == 3); + assert(static_cast<const B&>(a).id_ == 8); + throw; + } + catch (const C1&) + { + assert(false); + } + catch (const C2&) + { + assert(false); + } + catch (const B&) + { + assert(false); + } +} + +void f3() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f2(); + assert(false); + } + catch (const B& a) // can catch B + { + assert(static_cast<const B&>(a).id_ == 8); + throw; + } + catch (const C1& c1) + { + assert(false); + } + catch (const C2&) + { + assert(false); + } +} + +void f4() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f3(); + assert(false); + } + catch (const C2& c2) // can catch C2 + { + assert(c2.id_ == 3); + throw; + } + catch (const B& a) // can not catch B (ambiguous base) + { + assert(false); + } + catch (const C1&) + { + assert(false); + } +} + +void f5() +{ + try + { + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); + f4(); + assert(false); + } + catch (const C1& c1) // can catch C1 + { + assert(c1.id_ == 4); + assert(static_cast<const B&>(c1).id_ == 8); + throw; + } + catch (const B& a) + { + assert(false); + } + catch (const C2&) + { + assert(false); + } +} + +int main() +{ + try + { + f5(); + assert(false); + } + catch (...) + { + } + assert(A::count == 0); + assert(C1::count == 0); + assert(C2::count == 0); + assert(B::count == 0); +} diff --git a/libcxxabi/test/dynamic_cast_stress.cpp b/libcxxabi/test/dynamic_cast_stress.cpp index cc049cfa9ce..c3e5d0a29f5 100644 --- a/libcxxabi/test/dynamic_cast_stress.cpp +++ b/libcxxabi/test/dynamic_cast_stress.cpp @@ -52,8 +52,8 @@ void test() { typedef std::chrono::high_resolution_clock Clock; typedef std::chrono::duration<double, std::micro> US; - const std::size_t Width = 20; - const std::size_t Depth = 6; + const std::size_t Width = 10; + const std::size_t Depth = 5; A<Width, Depth> a; typedef B<Width/2, Depth> Destination; // typedef A<Width, Depth> Destination; |