blob: ad0c9ad8d79dd059de500e75a29a9c9241524358 [file] [log] [blame]
//===---------------------- 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);
}