| /external/clang/test/Lexer/ |
| cxx0x_keyword.cpp | 2 int static_assert; /* expected-error {{expected unqualified-id}} */ variable
|
| cxx0x_keyword_as_cxx98.cpp | 21 #define static_assert(b, s) int CONCAT(check, __LINE__)[(b) ? 1 : 0]; macro
22 static_assert(1 > 0, "hello"); // ok
35 int static_assert; // expected-warning {{'static_assert' is a keyword in C++11}} variable
|
| /external/clang/test/CodeGenCXX/ |
| static-assert.cpp | 3 static_assert(true, "");
6 static_assert(true, "");
|
| union-dtor.cpp | 7 Foo() { static_assert(b, "Foo::Foo used"); }
8 ~Foo() { static_assert(b, "Foo::~Foo used"); }
|
| /external/clang/test/SemaCXX/ |
| static-assert.cpp | 5 static_assert(f(), "f"); // expected-error {{static_assert expression is not an integral constant expression}}
6 static_assert(true, "true is not false");
7 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
10 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
14 static_assert(false, "false is false"); // expected-error {{static_assert failed "false is false"}}
18 static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed "N is not 2!"}
[all...] |
| attr-cxx0x.cpp | 15 static_assert(alignof(align_big) == alignof(int), "k's alignment is wrong");
16 static_assert(alignof(align_small) == 1, "j's alignment is wrong");
17 static_assert(alignof(align_multiple) == 8, "l's alignment is wrong");
18 static_assert(alignof(align_member) == 8, "quuux's alignment is wrong");
19 static_assert(sizeof(align_member) == 8, "quuux's size is wrong");
20 static_assert(alignof(align_typedef) == 8, "typedef's alignment is wrong");
21 static_assert(alignof(align_alias_template<int>) == 8, "alias template's alignment is wrong");
|
| trivial-constructor.cpp | 4 static_assert(__has_trivial_constructor(T1), "T1 has trivial constructor!");
9 static_assert(!__has_trivial_constructor(T2), "T2 has a user-declared constructor!");
14 static_assert(!__has_trivial_constructor(T3), "T3 has a virtual function!");
18 static_assert(!__has_trivial_constructor(T4), "T4 has a virtual base class!");
22 static_assert(__has_trivial_constructor(T5), "All the direct base classes of T5 have trivial constructors!");
29 static_assert(__has_trivial_constructor(T6), "All nonstatic data members of T6 have trivial constructors!");
34 static_assert(!__has_trivial_constructor(T7), "t4 does not have a trivial constructor!");
38 static_assert(!__has_trivial_constructor(T8), "The base class T2 does not have a trivial constructor!");
|
| trivial-destructor.cpp | 4 static_assert(__has_trivial_destructor(T1), "T1 has trivial destructor!");
9 static_assert(!__has_trivial_destructor(T2), "T2 has a user-declared destructor!");
14 static_assert(__has_trivial_destructor(T3), "T3 has a virtual function (but still a trivial destructor)!");
18 static_assert(__has_trivial_destructor(T4), "T4 has a virtual base class! (but still a trivial destructor)!");
22 static_assert(__has_trivial_destructor(T5), "All the direct base classes of T5 have trivial destructors!");
29 static_assert(__has_trivial_destructor(T6), "All nonstatic data members of T6 have trivial destructors!");
34 static_assert(!__has_trivial_destructor(T7), "t2 does not have a trivial destructor!");
38 static_assert(!__has_trivial_destructor(T8), "The base class T2 does not have a trivial destructor!");
|
| literal-type.cpp | 3 static_assert(__is_literal(int), "fail");
4 static_assert(__is_literal_type(int), "fail"); // alternate spelling for GCC
5 static_assert(__is_literal(void*), "fail");
7 static_assert(__is_literal(E), "fail");
8 static_assert(__is_literal(decltype(E1)), "fail");
10 static_assert(__is_literal(IAR), "fail");
13 static_assert(__is_literal(Vector), "fail");
14 static_assert(__is_literal(VectorExt), "fail");
42 static_assert(__is_literal(Empty), "fail");
43 static_assert(__is_literal(LiteralType), "fail")
[all...] |
| cxx0x-initializer-scalars.cpp | 9 { const int a{}; static_assert(a == 0, ""); }
10 { const int a = {}; static_assert(a == 0, ""); }
11 { const int a{1}; static_assert(a == 1, ""); }
12 { const int a = {1}; static_assert(a == 1, ""); }
46 static_assert(sizeof(overloaded({0})) == sizeof(one), "bad overload");
47 static_assert(sizeof(overloaded({0.0})) == sizeof(two), "bad overload");
|
| decltype-this.cpp | 12 void f() { static_assert(is_same<decltype(this), S*>::value, ""); }
13 void g() const { static_assert(is_same<decltype(this), const S*>::value, ""); }
14 void h() volatile { static_assert(is_same<decltype(this), volatile S*>::value, ""); }
15 void i() const volatile { static_assert(is_same<decltype(this), const volatile S*>::value, ""); }
|
| generic-selection.cpp | 13 static_assert(A<int>::id == 1, "fail");
14 static_assert(A<float>::id == 2, "fail");
15 static_assert(A<double, double>::id == 3, "fail");
44 static_assert(TypeMask<int, long, short>::result == 7, "fail");
45 static_assert(TypeMask<float, short>::result == 12, "fail");
46 static_assert(TypeMask<int, float, float>::result == 9, "fail");
|
| underlying_type.cpp | 18 static_assert(is_same_type<char, __underlying_type(f)>::value,
22 static_assert(is_same_type<int, __underlying_type(g)>::value,
26 static_assert(is_same_type<char, decltype(h)>::value,
34 static_assert(is_same_type<underlying_type<f>::type, char>::value,
|
| alignof-sizeof-reference.cpp | 7 static_assert(alignof(r) == 1, "bad alignment");
8 static_assert(sizeof(r) == 1, "bad size");
|
| cxx0x-defaulted-functions.cpp | 31 // FIXME: static_assert(__is_trivial(foo), "foo should be trivial");
33 static_assert(!__has_trivial_destructor(bar), "bar's destructor isn't trivial");
34 static_assert(!__has_trivial_constructor(bar),
36 static_assert(!__has_trivial_copy(bar), "bar has no trivial copy");
37 static_assert(!__has_trivial_assign(bar), "bar has no trivial assign");
|
| generalized-initializers.cpp | 47 static_assert(same_type<decltype(l), std::initializer_list<int>>::value, "");
62 A() { static_assert(N == 0, ""); }
63 A(int, double) { static_assert(N == 1, ""); }
64 A(std::initializer_list<int>) { static_assert(N == 3, ""); }
69 D(std::initializer_list<int>) { static_assert(N == 0, ""); } // expected-note 1 {{candidate}}
70 D(std::initializer_list<double>) { static_assert(N == 1, ""); } // expected-note 1 {{candidate}}
75 E(int, int) { static_assert(N == 0, ""); }
76 E(X1, int) { static_assert(N == 1, ""); }
|
| enum-scoped.cpp | 14 static_assert(sizeof(E1) == sizeof(int), "bad size");
15 static_assert(sizeof(E1::Val1) == sizeof(int), "bad size");
16 static_assert(sizeof(E2) == sizeof(int), "bad size");
17 static_assert(sizeof(E2::Val1) == sizeof(int), "bad size");
29 static_assert(sizeof(E3) == 1, "bad size");
|
| /external/clang/test/CXX/class/ |
| p6-0x.cpp | 10 static_assert(__is_trivial(Trivial), "Trivial is not trivial");
11 static_assert(!__is_trivial(NonTrivial1), "NonTrivial1 is trivial");
12 static_assert(!__is_trivial(NonTrivial2), "NonTrivial2 is trivial");
13 static_assert(!__is_trivial(NonTrivial3), "NonTrivial3 is trivial");
14 static_assert(!__is_trivial(NonTrivial4), "NonTrivial4 is trivial");
15 static_assert(!__is_trivial(NonTrivial5), "NonTrivial5 is trivial");
|
| /external/clang/test/CXX/dcl.dcl/dcl.spec/dcl.type/dcl.type.simple/ |
| p4-cxx0x.cpp | 18 static_assert(is_same<decltype(foo()), const int&&>::value, "");
19 static_assert(is_same<decltype(i), int>::value, "");
20 static_assert(is_same<decltype(a->x), double>::value, "");
21 static_assert(is_same<decltype((a->x)), const double&>::value, "");
|
| /external/clang/test/PCH/ |
| cxx-static_assert.cpp | 12 static_assert(N == 2, "N is not 2!"); // expected-error {{static_assert failed "N is not 2!"}}
|
| cxx_exprs.cpp | 31 static_assert(true_value, "true_value is true");
32 static_assert(!false_value, "false_value is false");
|
| /external/clang/test/SemaTemplate/ |
| instantiate-array.cpp | 7 #define static_assert(__b, __m) \ macro
15 static_assert(sizeof(IntArray<10>) == sizeof(int) * 10, "Array size mismatch");
16 static_assert(sizeof(IntArray<1>) == sizeof(int) * 1, "Array size mismatch");
22 static_assert(sizeof(TenElementArray<int>) == sizeof(int) * 10, "Array size mismatch");
28 static_assert(sizeof(Array<int, 10>) == sizeof(int) * 10, "Array size mismatch");
|
| /external/clang/test/CXX/special/class.copy/ |
| implicit-move.cpp | 47 static_assert(!noexcept(HasCopyConstructor((HasCopyConstructor()))), "");
49 static_assert(!noexcept(hcc = HasCopyConstructor()), "");
51 static_assert(!noexcept(HasCopyAssignment((HasCopyAssignment()))), "");
53 static_assert(!noexcept(hca = HasCopyAssignment()), "");
55 static_assert(noexcept(HasMoveConstructor((HasMoveConstructor()))), "");
61 static_assert(noexcept(hma = HasMoveAssignment()), "");
63 static_assert(!noexcept(HasDestructor((HasDestructor()))), "");
65 static_assert(!noexcept(hd = HasDestructor()), "");
127 static_assert(!noexcept(InheritsPrivateMove(InheritsPrivateMove())), "");
128 static_assert(!noexcept(ContainsPrivateMove(ContainsPrivateMove())), "")
[all...] |
| /external/clang/test/CXX/temp/temp.fct.spec/temp.deduct/temp.deduct.type/ |
| p8-0x.cpp | 42 static_assert(member_pointer_kind<int (X::*)(int)>::value == 1, "");
43 static_assert(member_pointer_kind<int (X::*)(int) &>::value == 2, "");
44 static_assert(member_pointer_kind<int (X::*)(int) &&>::value == 3, "");
45 static_assert(member_pointer_kind<int (X::*)(int) const>::value == 4, "");
46 static_assert(member_pointer_kind<int (X::*)(int) const&>::value == 5, "");
47 static_assert(member_pointer_kind<int (X::*)(int) const&&>::value == 6, "");
|
| /external/clang/test/CXX/special/class.ctor/ |
| p5-0x.cpp | 135 static_assert(__has_trivial_constructor(Trivial), "Trivial is nontrivial");
139 static_assert(!__has_trivial_constructor(NonTrivialDefCtor1), "NonTrivialDefCtor1 is trivial");
143 static_assert(!__has_trivial_constructor(NonTrivialDefCtor2), "NonTrivialDefCtor2 is trivial");
145 static_assert(!__has_trivial_constructor(NonTrivialDefCtor3), "NonTrivialDefCtor3 is trivial");
149 static_assert(!__has_trivial_constructor(NonTrivialDefCtor4), "NonTrivialDefCtor4 is trivial");
153 static_assert(!__has_trivial_constructor(NonTrivialDefCtor5), "NonTrivialDefCtor5 is trivial");
158 static_assert(!__has_trivial_constructor(NonTrivialDefCtor6), "NonTrivialDefCtor5 is trivial");
162 //static_assert(__has_trivial_constructor(Trivial2), "NonTrivialDefCtor2 is trivial");
164 static_assert(!__has_trivial_constructor(Trivial2), "NonTrivialDefCtor2 is trivial");
167 //static_assert(__has_trivial_constructor(Trivial3), "NonTrivialDefCtor3 is trivial")
[all...] |
