/*******************************************************************************
* Copyright (c) 2005, 2016 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Eclipse Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/epl-v10.html
*
* Contributors:
* Devin Steffler (IBM Corporation) - initial API and implementation
* Markus Schorn (Wind River Systems)
* Sergey Prigogin (Google)
* Nathan Ridge
*******************************************************************************/
package org.eclipse.cdt.core.parser.tests.ast2;
import junit.framework.TestSuite;
import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
import org.eclipse.cdt.core.dom.ast.IASTCompositeTypeSpecifier;
import org.eclipse.cdt.core.dom.ast.IASTDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTExpression;
import org.eclipse.cdt.core.dom.ast.IASTExpressionList;
import org.eclipse.cdt.core.dom.ast.IASTFunctionDefinition;
import org.eclipse.cdt.core.dom.ast.IASTImplicitName;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.core.dom.ast.IASTProblemDeclaration;
import org.eclipse.cdt.core.dom.ast.IASTTranslationUnit;
import org.eclipse.cdt.core.dom.ast.IASTTypeId;
import org.eclipse.cdt.core.dom.ast.IBasicType;
import org.eclipse.cdt.core.dom.ast.IBinding;
import org.eclipse.cdt.core.dom.ast.IFunction;
import org.eclipse.cdt.core.dom.ast.IProblemBinding;
import org.eclipse.cdt.core.dom.ast.IType;
import org.eclipse.cdt.core.dom.ast.ITypedef;
import org.eclipse.cdt.core.dom.ast.IVariable;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTNewExpression;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTTemplateId;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPASTUsingDeclaration;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunction;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPFunctionTemplate;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPSpecialization;
import org.eclipse.cdt.core.dom.ast.cpp.ICPPTemplateInstance;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.internal.core.dom.parser.cpp.ICPPUnknownBinding;
import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.CPPVisitor;
/**
* Examples taken from the c++-specification.
*/
public class AST2CPPSpecTest extends AST2SpecTestBase {
public AST2CPPSpecTest() {
}
public AST2CPPSpecTest(String name) {
super(name);
}
public static TestSuite suite() {
return suite(AST2CPPSpecTest.class);
}
// int x=x+++++y;
public void test2_4s5() throws Exception {
parseCandCPP(getAboveComment(), false, 0);
}
// int a=12, b=014, c=0XC;
public void test2_13_1s1() throws Exception {
parseCandCPP(getAboveComment(), true, 0);
}
// ??=define arraycheck(a,b) a??(b??) ??!??! b??(a??)
// // becomes
// #define arraycheck(a,b) a[b] || b[a]
public void test2_3s2() throws Exception { // TODO exists bug 64993
parseCandCPP(getAboveComment(), true, 0);
}
// int a; // defines a
// extern const int c = 1; // defines c
// int f(int x) { return x+a; } // defines f and defines x
// struct S { int a; int b; }; // defines S, S::a, and S::b
// struct X { // defines X
// int x; // defines nonstatic data member x
// static int y; // declares static data member y
// X(): x(0) { } // defines a constructor of X
// };
// int X::y = 1; // defines X::y
// enum { up, down }; // defines up and down
// namespace N { int d; } // defines N and N::d
// namespace N1 = N; // defines N1
// X anX; // defines anX
// // whereas these are just declarations:
// extern int a; // declares a
// extern const int c; // declares c
// int f(int); // declares f
// struct S; // declares S
// typedef int Int; // declares Int
// extern X anotherX; // declares anotherX
// using N::d; // declares N::d
public void test3_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct C {
// string s; // string is the standard library class (clause 21)
// };
// int main()
// {
// C a;
// C b = a;
// b = a;
// }
public void test3_1s4a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct C {
// string s;
// C(): s() { }
// C(const C& x): s(x.s) { }
// C& operator=(const C& x) { s = x.s; return *this; }
// ~C() { }
// };
//
public void test3_1s4b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct X; // declare X as a struct type
// struct X* x1; // use X in pointer formation
// X* x2; // use X in pointer formation
public void test3_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // translation unit 1:
// struct X {
// X(int);
// X(int, int);
// };
// X::X(int = 0) { }
// class D: public X { };
// D d2; // X(int) called by D()
public void test3_2s5_a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // translation unit 2:
// struct X {
// X(int);
// X(int, int);
// };
// X::X(int = 0, int = 0) { }
// class D: public X { }; // X(int, int) called by D();
// // D()'s implicit definition
// // violates the ODR
public void test3_2s5_b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int j = 24;
// int main()
// {
// int i = j, j;
// j = 42;
// }
public void test3_3s2() throws Exception {
parseCandCPP(getAboveComment(), true, 0);
}
// int foo() {
// int x = 12;
// { int x = x; }
// }
public void test3_3_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// const int i = 2;
// { int i[i]; }
// }
public void test3_3_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// const int x = 12;
// { enum { x = x }; }
// }
public void test3_3_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// int i;
// int g(int a) { return a; }
// int j();
// void q();
// }
// namespace { int l=1; }
// // the potential scope of l is from its point of declaration
// // to the end of the translation unit
// namespace N {
// int g(char a) // overloads N::g(int)
// {
// return l+a; // l is from unnamed namespace
// }
// int i; // error: duplicate definition
// int j(); // OK: duplicate function declaration
// int j() // OK: definition of N::j()
// {
// return g(i); // calls N::g(int)
// }
// int q(); // error: different return type
// }
public void test3_3_5s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// namespace N {
// void f();
// }
// }
// void A::N::f() {
// int i = 5;
// // The following scopes are searched for a declaration of i:
// // 1) outermost block scope of A::N::f, before the use of i
// // 2) scope of namespace N
// // 3) scope of namespace A
// // 4) global scope, before the definition of A::N::f
// }
public void test3_4_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace M {
// class B { };
// }
public void test3_4_1s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B { };
// namespace M {
// namespace N {
// class X : public B {
// void f();
// };
// }
// }
// void M::N::X::f() {
// int i = 16;
// }
// // The following scopes are searched for a declaration of i:
// // 1) outermost block scope of M::N::X::f, before the use of i
// // 2) scope of class M::N::X
// // 3) scope of M::N::X's base class B
// // 4) scope of namespace M::N
// // 5) scope of namespace M
// // 6) global scope, before the definition of M::N::X::f
public void test3_4_1s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// typedef int AT;
// void f1(AT);
// void f2(float);
// };
// struct B {
// typedef float BT;
// friend void A::f1(AT); // parameter type is A::AT
// friend void A::f2(BT); // parameter type is B::BT
// };
public void test3_4_1s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// public:
// static int n;
// };
// int main()
// {
// int A;
// A::n = 42; // OK
// A b; // illformed: A does not name a type
// }
public void test3_4_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 1);
}
// namespace NS {
// class T { };
// void f(T);
// }
// NS::T parm;
// int main() {
// f(parm); //OK: calls NS::f
// }
public void test3_4_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X { };
// class C {
// class X { };
// static const int number = 50;
// static X arr[number];
// };
// X C::arr[number]; // illformed:
// // equivalent to: ::X C::arr[C::number];
// // not to: C::X C::arr[C::number];
public void test3_4_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct C {
// typedef int I;
// };
// typedef int I1, I2;
// int foo() {
// extern int* p;
// extern int* q;
// p->C::I::~I(); // I is looked up in the scope of C
// q->I1::~I2(); // I2 is looked up in the scope of
// };
// // the postfixexpression
// struct A {
// ~A();
// };
// typedef A AB;
// int main()
// {
// AB *p;
// p->AB::~AB(); // explicitly calls the destructor for A
// }
public void test3_4_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int x;
// namespace Y {
// void f(float);
// void h(int);
// }
// namespace Z {
// void h(double);
// }
// namespace A {
// using namespace Y;
// void f(int);
// void g(int);
// int i;
// }
// namespace B {
// using namespace Z;
// void f(char);
// int i;
// }
// namespace AB {
// using namespace A;
// using namespace B;
// void g();
// }
// void h()
// {
// AB::g(); // g is declared directly in AB,
// // therefore S is { AB::g() } and AB::g() is chosen
// AB::f(1); // f is not declared directly in AB so the rules are
// // applied recursively to A and B;
// // namespace Y is not searched and Y::f(float)
// // is not considered;
// // S is { A::f(int), B::f(char) } and overload
// // resolution chooses A::f(int)
// AB::f('c'); //as above but resolution chooses B::f(char)
// AB::x++; // x is not declared directly in AB, and
// // is not declared in A or B, so the rules are
// // applied recursively to Y and Z,
// // S is { } so the program is illformed
// AB::i++; // i is not declared directly in AB so the rules are
// // applied recursively to A and B,
// // S is { A::i, B::i } so the use is ambiguous
// // and the program is illformed
// AB::h(16.8); // h is not declared directly in AB and
// // not declared directly in A or B so the rules are
// // applied recursively to Y and Z,
// // S is { Y::h(int), Z::h(double) } and overload
// // resolution chooses Z::h(double)
// }
public void test3_4_3_2s2() throws Exception {
String[] problems= {"AB::x", "x", "AB::i", "i"};
parse(getAboveComment(), ParserLanguage.CPP, problems); // qualified names are counted double, so 4
}
// namespace A {
// int a;
// }
// namespace B {
// using namespace A;
// }
// namespace C {
// using namespace A;
// }
// namespace BC {
// using namespace B;
// using namespace C;
// }
// void f()
// {
// BC::a++; //OK: S is { A::a, A::a }
// }
// namespace D {
// using A::a;
// }
// namespace BD {
// using namespace B;
// using namespace D;
// }
// void g()
// {
// BD::a++; //OK: S is { A::a, A::a }
// }
public void test3_4_3_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace B {
// int b;
// }
// namespace A {
// using namespace B;
// int a;
// }
// namespace B {
// using namespace A;
// }
// void f()
// {
// A::a++; //OK: a declared directly in A, S is { A::a }
// B::a++; //OK: both A and B searched (once), S is { A::a }
// A::b++; //OK: both A and B searched (once), S is { B::b }
// B::b++; //OK: b declared directly in B, S is { B::b }
// }
public void test3_4_3_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// struct x { };
// int x;
// int y;
// }
// namespace B {
// struct y {};
// }
// namespace C {
// using namespace A;
// using namespace B;
// int i = C::x; // OK, A::x (of type int)
// int j = C::y; // ambiguous, A::y or B::y
// }
public void test3_4_3_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// namespace B {
// void f1(int);
// }
// using namespace B;
// }
// void A::f1(int) { } // illformed,
// // f1 is not a member of A
public void test3_4_3_2s6a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// namespace B {
// void f1(int);
// }
// }
// namespace C {
// namespace D {
// void f1(int);
// }
// }
// using namespace A;
// using namespace C::D;
// void B::f1(int){} // OK, defines A::B::f1(int)
public void test3_4_3_2s6b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct Node {
// struct Node* Next; // OK: Refers to Node at global scope
// struct Data* Data; // OK: Declares type Data
// // at global scope and member Data
// };
// struct Data {
// struct Node* Node; // OK: Refers to Node at global scope
// friend struct ::Glob; // error: Glob is not declared
// // cannot introduce a qualified type (7.1.5.3)
// friend struct Glob; // OK: Refers to (as yet) undeclared Glob
// // at global scope.
//
// };
// struct Base {
// struct Data; // OK: Declares nested Data
// struct ::Data* thatData; // OK: Refers to ::Data
// struct Base::Data* thisData; // OK: Refers to nested Data
// friend class ::Data; // OK: global Data is a friend
// friend class Data; // OK: nested Data is a friend
// struct Data { //
// }; // Defines nested Data
// struct Data; // OK: Redeclares nested Data
// };
// struct Data; // OK: Redeclares Data at global scope
// struct ::Data; // error: cannot introduce a qualified type (7.1.5.3)
// struct Base::Data; // error: cannot introduce a qualified type (7.1.5.3)
// struct Base::Datum; // error: Datum undefined
// struct Base::Data* pBase; // OK: refers to nested Data
public void test3_4_4s3() throws Exception {
String[] problems= {"::Glob", "Glob", "Base::Datum", "Datum"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// static void f();
// static int i = 0; //1
// void g() {
// extern void f(); // internal linkage
// int i; //2: i has no linkage
// {
// extern void f(); // internal linkage
// extern int i; //3: external linkage
// }
// }
public void test3_5s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace X {
// void p()
// {
// q(); //error: q not yet declared
// extern void q(); // q is a member of namespace X
// }
// void middle()
// {
// q(); //error: q not yet declared
// }
// void q() { //
// } // definition of X::q
// }
// void q() { //
// } // some other, unrelated q
public void test3_5s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void f()
// {
// struct A { int x; }; // no linkage
// extern A a; // illformed
// typedef A B;
// extern B b; // illformed
// }
public void test3_5s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int main(int argc, char* argv[]) { //
// }
public void test3_6_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual void f();
// void mutate();
// virtual ~B();
// };
// struct D1 : B { void f(); };
// struct D2 : B { void f(); };
// void B::mutate() {
// new (this) D2; // reuses storage - ends the lifetime of *this
// f(); //undefined behavior
// this; // OK, this points to valid memory
// }
// void g() {
// void* p = malloc(sizeof(D1) + sizeof(D2));
// B* pb = new (p) D1;
// pb->mutate();
// &pb; //OK: pb points to valid memory
// void* q = pb; // OK: pb points to valid memory
// pb->f(); //undefined behavior, lifetime of *pb has ended
// }
public void test3_8s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct C {
// int i;
// void f();
// const C& operator=( const C& );
// };
// const C& C::operator=( const C& other)
// {
// if ( this != &other ) {
// this->~C(); //lifetime of *this ends
// new (this) C(other); // new object of type C created
// f(); //welldefined
// }
// return *this;
// }
// int foo() {
// C c1;
// C c2;
// c1 = c2; // welldefined
// c1.f(); //welldefined; c1 refers to a new object of type C
// }
public void test3_8s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class T { };
// struct B {
// ~B();
// };
// void h() {
// B b;
// new (&b) T;
// } //undefined behavior at block exit
public void test3_8s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// B();
// ~B();
// };
// const B b;
// void h() {
// b.~B();
// new (&b) const B; // undefined behavior
// }
public void test3_8s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// #define N sizeof(T)
// void test() {
// char buf[N];
// T obj; // obj initialized to its original value
// memcpy(buf, &obj, N); // between these two calls to memcpy,
// // obj might be modified
// memcpy(&obj, buf, N); // at this point, each subobject of obj of scalar type
// // holds its original value
// }
public void test3_9s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void test() {
// T* t1p;
// T* t2p;
// // provided that t2p points to an initialized object ...
// memcpy(t1p, t2p, sizeof(T)); // at this point, every subobject of POD type in *t1p contains
// // the same value as the corresponding subobject in *t2p
// }
public void test3_9s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class X; // X is an incomplete type
// extern X* xp; // xp is a pointer to an incomplete type
// extern int arr[]; // the type of arr is incomplete
// typedef int UNKA[]; // UNKA is an incomplete type
// UNKA* arrp; // arrp is a pointer to an incomplete type
// UNKA** arrpp;
// void foo() {
// xp++; //ill-formed: X is incomplete
// arrp++; //ill-formed: incomplete type
// arrpp++; //OK: sizeof UNKA* is known
// }
// struct X {
// int i;
// }; // now X is a complete type
// int arr[10]; // now the type of arr is complete
// X x;
// void bar() {
// xp = &x; // OK; type is ''pointer to X''
// arrp = &arr; // ill-formed: different types
// xp++; //OK: X is complete
// arrp++; //ill-formed: UNKA can't be completed
// }
public void test3_9s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int& f();
public void test3_10s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// i = v[i++]; // the behavior is unspecified
// i = 7, i++, i++; // i becomes 9
// i = ++i + 1; // the behavior is unspecified
// i = i + 1; // the value of i is incremented
// }
public void test5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct B {};
// struct D : B {};
// void foo(D* dp)
// {
// B* bp = dynamic_cast<B*>(dp); // equivalent to B* bp = dp;
// }
public void test5_2_7s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A { virtual void f(); };
// class B { virtual void g(); };
// class D : public virtual A, private B {};
// void g()
// {
// D d;
// B* bp = (B*)&d; // cast needed to break protection
// A* ap = &d; // public derivation, no cast needed
// D& dr = dynamic_cast<D&>(*bp); // fails
// ap = dynamic_cast<A*>(bp); // fails
// bp = dynamic_cast<B*>(ap); // fails
// ap = dynamic_cast<A*>(&d); // succeeds
// bp = dynamic_cast<B*>(&d); // fails
// }
// class E : public D, public B {};
// class F : public E, public D {};
// void h()
// {
// F f;
// A* ap = &f; // succeeds: finds unique A
// D* dp = dynamic_cast<D*>(ap); // fails: yields 0
// // f has two D subobjects
// E* ep = (E*)ap; // illformed:
// // cast from virtual base
// E* ep1 = dynamic_cast<E*>(ap); // succeeds
// }
public void test5_2_7s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class D { // ...
// };
// D d1;
// const D d2;
// int foo() {
// typeid(d1) == typeid(d2); // yields true
// typeid(D) == typeid(const D); // yields true
// typeid(D) == typeid(d2); // yields true
// typeid(D) == typeid(const D&); // yields true
// }
public void test5_2_8s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {};
// struct D : public B {};
// D d;
// B &br = d;
// int foo() {
// static_cast<D&>(br); // produces lvalue to the original d object
// }
public void test5_2_9s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A { int i; };
// struct B : A { };
// int foo() {
// &B::i; // has type int A::*
// }
public void test5_3_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void test() {
// new (int (*[10])());
// };
public void test5_3_4s3() throws Exception {
IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 0);
IASTFunctionDefinition fdef= getDeclaration(tu, 0);
IASTExpression expr= getExpressionOfStatement(fdef, 0);
assertInstance(expr, ICPPASTNewExpression.class);
ICPPASTNewExpression newExpr= (ICPPASTNewExpression) expr;
assertNull(newExpr.getNewPlacement());
assertNull(newExpr.getNewInitializer());
IASTTypeId typeid= newExpr.getTypeId();
isTypeEqual(CPPVisitor.createType(typeid), "int (* [10])()");
}
// typedef int T;
// void test(int f) {
// new T;
// new(2,f) T;
// new T[5];
// new (2,f) T[5];
// };
public void test5_3_4s12() throws Exception {
// see https://bugs.eclipse.org/bugs/show_bug.cgi?id=236856
IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 0);
IASTFunctionDefinition fdef= getDeclaration(tu, 1);
// new T;
IASTExpression expr= getExpressionOfStatement(fdef, 0);
assertInstance(expr, ICPPASTNewExpression.class);
ICPPASTNewExpression newExpr= (ICPPASTNewExpression) expr;
assertNull(newExpr.getNewPlacement());
assertNull(newExpr.getNewInitializer());
isTypeEqual(CPPVisitor.createType(newExpr.getTypeId()), "int");
// new(2,f) T;
expr= getExpressionOfStatement(fdef, 1);
assertInstance(expr, ICPPASTNewExpression.class);
newExpr= (ICPPASTNewExpression) expr;
assertInstance(newExpr.getNewPlacement(), IASTExpressionList.class);
assertNull(newExpr.getNewInitializer());
isTypeEqual(CPPVisitor.createType(newExpr.getTypeId()), "int");
// new T[5];
expr= getExpressionOfStatement(fdef, 2);
assertInstance(expr, ICPPASTNewExpression.class);
newExpr= (ICPPASTNewExpression) expr;
assertNull(newExpr.getNewPlacement());
assertNull(newExpr.getNewInitializer());
isTypeEqual(CPPVisitor.createType(newExpr.getTypeId()), "int [5]");
// new (2,f) T[5];
expr= getExpressionOfStatement(fdef, 3);
assertInstance(expr, ICPPASTNewExpression.class);
newExpr= (ICPPASTNewExpression) expr;
assertInstance(newExpr.getNewPlacement(), IASTExpressionList.class);
assertNull(newExpr.getNewInitializer());
isTypeEqual(CPPVisitor.createType(newExpr.getTypeId()), "int [5]");
}
// int n=2;
// int x=new float[n][5];
// int y=new float[5][n];
public void test5_3_4s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// const char* strchr(const char* s, int c);
// bool b = noexcept (strchr("abc", 'b'));
public void test5_3_7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {};
// struct I1 : A {};
// struct I2 : A {};
// struct D : I1, I2 {};
// A *foo( D *p ) {
// return (A*)( p ); // illformed
// // static_cast interpretation
// }
public void test5_4s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// (ptr_to_obj->*ptr_to_mfct)(10);
// }
public void test5_5s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void *p;
// const int *q;
// int **pi;
// const int *const *pci;
// void ct()
// {
// p <= q; // Both converted to const void * before comparison
// pi <= pci; // Both converted to const int *const * before comparison
// }
public void test5_9s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// int f();
// };
// struct L : B { };
// struct R : B { };
// struct D : L, R { };
// int (B::*pb)() = &B::f;
// int (L::*pl)() = pb;
// int (R::*pr)() = pb;
// int (D::*pdl)() = pl;
// int (D::*pdr)() = pr;
// bool x = (pdl == pdr); // false
public void test5_10s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(int, int, int) {}
// int foo() {
// int a=0, t=1, c=2;
// f(a, (t=3, t+2), c);
// }
public void test5_18s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// int x=0;
// if (x)
// int i;
//
// if (x) {
// int i;
// }
// }
public void test6_4s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// if (int x = 1) {
// int x; // illformed,redeclaration of x
// }
// else {
// int x; // illformed,redeclaration of x
// }
// }
public void test6_4s3() throws Exception {
// raised bug 90618
// gcc does not report an error, either, so leave it as it is.
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// int x=5;
// while (--x >= 0)
// int i;
// //can be equivalently rewritten as
// while (--x >= 0) {
// int i;
// }
// }
public void test6_5s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// int val;
// A(int i) : val(i) { }
// ~A() { }
// operator bool() { return val != 0; }
// };
//
// int foo() {
// int i = 1;
// while (A a = i) {
// //...
// i = 0;
// }
// }
public void test6_5_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// int i = 42;
// int a[10];
// for (int i = 0; i < 10; i++)
// a[i] = i;
// int j = i; // j = 42
// }
public void test6_5_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f()
// {
// // ...
// goto lx; // illformed: jump into scope of a
// // ...
// ly:
// X a = 1; // X is undefined
// // ...
// lx:
// goto ly; // OK, jump implies destructor
// // call for a followed by construction
// // again immediately following label ly
// }
public void test6_7s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 1);
}
// int foo(int i)
// {
// static int s = foo(2*i); // recursive call - undefined
// return i+1;
// }
public void test6_7s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// T(a)->m = 7; // expressionstatement
// T(a)++; //expressionstatement
// T(a,5)<<c; //expressionstatement
// T(*d)(int); //declaration
// T(e)[5]; //declaration
// T(f) = { 1, 2 }; // declaration
// T(*g)(double(3)); // declaration
// }
public void test6_8s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class T {
// // ...
// public:
// T();
// T(int);
// T(int, int);
// };
// T(a); //declaration
// T(*b)(); //declaration
// T(c)=7; //declaration
// T(d),e,f=3; //declaration
// extern int h;
// T(g)(h,2); //declaration
public void test6_8s2() throws Exception { // TODO raised bug 90622
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct T1 {
// T1 operator()(int x) { return T1(x); }
// int operator=(int x) { return x; }
// T1(int) { }
// };
// struct T2 { T2(int){ } };
// int a, (*(*b)(T2))(int), c, d;
// void f() {
// // disambiguation requires this to be parsed
// // as a declaration
// T1(a) = 3,
// T2(4), // T2 will be declared as
// (*(*b)(T2(c)))(int(d)); // a variable of type T1
// // but this will not allow
// // the last part of the
// // declaration to parse
// // properly since it depends
// // on T2 being a typename
// }
public void test6_8s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef char* Pc;
// void f(const Pc); // void f(char* const) (not const char*)
// void g(const int Pc); // void g(const int)
public void test7_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void h(unsigned Pc); // void h(unsigned int)
// void k(unsigned int Pc); // void k(unsigned int)
public void test7_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// thread_local int e;
// static thread_local int f;
// extern thread_local int g;
public void test7_1_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// static char* f(); // f() has internal linkage
// char* f() // f() still has internal linkage
// { //
// }
// char* g(); // g() has external linkage
// static char* g() // error: inconsistent linkage
// { //
// }
// void h();
// inline void h(); // external linkage
// inline void l();
// void l(); // external linkage
// inline void m();
// extern void m(); // external linkage
// static void n();
// inline void n(); // internal linkage
// static int a; // a has internal linkage
// int a; // error: two definitions
// static int b; // b has internal linkage
// extern int b; // b still has internal linkage
// int c; // c has external linkage
// static int c; // error: inconsistent linkage
// extern int d; // d has external linkage
// static int d; // error: inconsistent linkage
public void test7_1_1s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S;
// extern S a;
// extern S f();
// extern void g(S);
// void h()
// {
// g(a); //error: S is incomplete
// f(); //error: S is incomplete
// }
public void test7_1_1s8a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// mutable const int* p; // OK
// mutable int* const q; // illformed
// };
public void test7_1_1s8b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int MILES, *KLICKSP;
// MILES distance;
// extern KLICKSP metricp;
public void test7_1_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef struct s { //
// } s;
// typedef int I;
// typedef int I;
// typedef I I;
public void test7_1_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class complex { //
// };
// typedef int complex; // error: redefinition
public void test7_1_3s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int complex;
// class complex { //
// }; // error: redefinition
public void test7_1_3s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// S();
// ~S();
// };
// typedef struct S T;
// S a = T(); // OK
// struct T * p; // error
public void test7_1_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef struct { } *ps, S; // S is the class name for linkage purposes
public void test7_1_3s5a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef struct {
// S(); //error: requires a return type because S is
// // an ordinary member function, not a constructor
// } S;
public void test7_1_3s5b() throws Exception {
IASTTranslationUnit tu= parseWithErrors(getAboveComment(), ParserLanguage.CPP);
IASTCompositeTypeSpecifier comp= getCompositeType(tu, 0);
IASTDeclaration d= getDeclaration(comp, 0);
assertInstance(d, IASTProblemDeclaration.class);
}
// constexpr int square(int x);
// constexpr int bufsz = 1024;
// struct pixel {
// int x;
// int y;
// constexpr pixel(int);
// };
// constexpr pixel::pixel(int a)
// : x(square(a)), y(square(a))
// { }
// constexpr int square(int x) {
// return x * x;
// }
// constexpr pixel large(4);
public void test7_1_5s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// const int ci = 3; // cvqualified (initialized as required)
// ci = 4; // illformed: attempt to modify const
// int i = 2; // not cvqualified
// const int* cip; // pointer to const int
// cip = &i; // OK: cvqualified access path to unqualified
// *cip = 4; // illformed: attempt to modify through ptr to const
// int* ip;
// ip = const_cast<int*>(cip); // cast needed to convert const int* to int*
// *ip = 4; // defined: *ip points to i, a nonconst object
// const int* ciq = new const int (3); // initialized as required
// int* iq = const_cast<int*>(ciq); // cast required
// *iq = 4; // undefined: modifies a const object
// }
public void test7_1_5_1s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// mutable int i;
// int j;
// };
// class Y {
// public:
// X x;
// Y();
// };
//
// int foo() {
// const Y y;
// y.x.i++; //wellformed: mutable member can be modified
// y.x.j++; //illformed: constqualified member modified
// Y* p = const_cast<Y*>(&y); // cast away constness of y
// p->x.i = 99; // wellformed: mutable member can be modified
// p->x.j = 99; // undefined: modifies a const member
// }
public void test7_1_5_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// enum { a, b, c=0 };
// enum { d, e, f=e+2 };
public void test7_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// const int x = 12;
// { enum { x = x }; }
// }
public void test7_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// enum color { red, yellow, green=20, blue };
// color col = red;
// color* cp = &col;
// if (*cp == blue) // ...
// return 0;
// }
public void test7_2s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// enum direction { left='l', right='r' };
// int f(int i)
// { return i==left ? 0 : i==right ? 1 : 2; }
// };
// void g(X* p)
// {
// direction d; // error: direction not in scope
// int i;
// i = p->f(left); // error: left not in scope
// i = p>
// f(X::right); // OK
// i = p>
// f(p->left); // OK
// // ...
// }
public void test7_2s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// namespace Outer {
// int i;
// namespace Inner {
// void f() { i++; } // Outer::i
// int i;
// void g() { i++; } // Inner::i
// }
// }
public void test7_3_1s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace { int i; } // unique::i
// void f() { i++; } // unique::i++
// namespace A {
// namespace {
// int i; // A::unique::i
// int j; // A::unique::j
// }
// void g() { i++; } // A::unique::i++
// }
// using namespace A;
// void h() {
// i++; //error: unique::i or A::unique::i
// A::i++; // A::unique::i
// j++; // A::unique::j
// }
public void test7_3_1_1s1() throws Exception {
String[] problems= {"i"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// namespace X {
// void f() { //
// }
// }
public void test7_3_1_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace Q {
// namespace V {
// void f();
// }
// void V::f() { } // OK
// void V::g() { } // error: g() is not yet a member of V
// namespace V {
// void g();
// }
// }
// namespace R {
// void Q::V::g() { } // error: R doesn't enclose Q
// }
public void test7_3_1_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 2);
}
// // Assume f and g have not yet been defined.
// void h(int);
// namespace A {
// class X {
// friend void f(X); // A::f is a friend
// class Y {
// friend void g(); // A::g is a friend
// friend void h(int); // A::h is a friend
// // ::h not considered
// };
// };
// // A::f, A::g and A::h are not visible here
// X x;
// void g() { f(x); } // definition of A::g
// void f(X) { } // definition of A::f
// void h(int) { } // definition of A::h
// // A::f, A::g and A::h are visible here and known to be friends
// }
// using A::x;
// void h()
// {
// A::f(x);
// A::X::f(x); //error: f is not a member of A::X
// A::X::Y::g(); // error: g is not a member of A::X::Y
// }
public void test7_3_1_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 4);
}
// namespace Company_with_very_long_name { }
// namespace CWVLN = Company_with_very_long_name;
// namespace CWVLN = Company_with_very_long_name; // OK: duplicate
// namespace CWVLN = CWVLN;
public void test7_3_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// void f(char);
// void g(char);
// enum E { e };
// union { int x; };
// };
// struct D : B {
// using B::f;
// void f(int) { f('c'); } // calls B::f(char)
// void g(int) { g('c'); } // recursively calls D::g(int)
// };
public void test7_3_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C {
// int g();
// };
// class D2 : public B {
// using B::f; // OK: B is a base of D2
// using B::e; // OK: e is an enumerator of base B
// using B::x; // OK: x is a union member of base B
// using C::g; // error: C isn't a base of D2
// };
public void test7_3_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class A {
// public:
// template <class T> void f(T);
// template <class T> struct X { };
// };
// class B : public A {
// public:
// using A::f<double>; // illformed
// using A::X<int>; // illformed
// };
public void test7_3_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// int i;
// static int s;
// };
// void f()
// {
// using X::i; // error: X::i is a class member
// // and this is not a member declaration.
// using X::s; // error: X::s is a class member
// // and this is not a member declaration.
// }
public void test7_3_3s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f();
// namespace A {
// void g();
// }
// namespace X {
// using ::f; // global f
// using A::g; // A's g
// }
// void h()
// {
// X::f(); //calls ::f
// X::g(); //calls A::g
// }
public void test7_3_3s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// int i;
// }
// namespace A1 {
// using A::i;
// using A::i; // OK: double declaration
// }
// void f()
// {
// using A::i;
// using A::i; // error: double declaration
// }
// class B {
// public:
// int i;
// };
// class X : public B {
// using B::i;
// using B::i; // error: double member declaration
// };
public void test7_3_3s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// void f(int);
// }
// using A::f; // f is a synonym for A::f;
// // that is, for A::f(int).
// namespace A {
// void f(char);
// }
// void foo()
// {
// f('a'); //calls f(int),
// } //even though f(char) exists.
// void bar()
// {
// using A::f; // f is a synonym for A::f;
// // that is, for A::f(int) and A::f(char).
// f('a'); //calls f(char)
// }
public void test7_3_3s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual void f(int);
// virtual void f(char);
// void g(int);
// void h(int);
// };
// struct D : B {
// using B::f;
// void f(int); // OK: D::f(int) overrides B::f(int);
// using B::g;
// void g(char); // OK
// using B::h;
// void h(int); // OK: D::h(int) hides B::h(int)
// };
// void k(D* p)
// {
// p->f(1); //calls D::f(int)
// p->f('a'); //calls B::f(char)
// p->g(1); //calls B::g(int)
// p->g('a'); //calls D::g(char)
// }
public void test7_3_3s12() throws Exception { // raised bug 161562 for that
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// int x;
// }
// namespace B {
// int i;
// struct g { };
// struct x { };
// void f(int);
// void f(double);
// void g(char); // OK: hides struct g
// }
// void func()
// {
// int i;
// //using B::i; // error: i declared twice
// void f(char);
// using B::f; // OK: each f is a function
// f(3.5); //calls B::f(double)
// using B::g;
// g('a'); //calls B::g(char)
// struct g g1; // g1 has class type B::g
// using B::x;
// using A::x; // OK: hides struct B::x
// x = 99; // assigns to A::x
// struct x x1; // x1 has class type B::x
// }
public void test7_3_3s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace B {
// void f(int);
// void f(double);
// }
// namespace C {
// void f(int);
// void f(double);
// void f(char);
// }
// void h()
// {
// using B::f; // B::f(int) and B::f(double)
// using C::f; // C::f(int), C::f(double), and C::f(char)
// f('h'); //calls C::f(char)
// f(1); //error: ambiguous: B::f(int) or C::f(int) ?
// void f(int); // error:
// // f(int) conflicts with C::f(int) and B::f(int)
// }
public void test7_3_3s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A { int x(); };
// struct B : A { };
// struct C : A {
// using A::x;
// int x(int);
// };
// struct D : B, C {
// using C::x;
// int x(double);
// };
// int f(D* d) {
// return d>
// x(); // ambiguous: B::x or C::x
// }
public void test7_3_3s14() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class A {
// private:
// void f(char);
// public:
// void f(int);
// protected:
// void g();
// };
// class B : public A {
// using A::f; // error: A::f(char) is inaccessible
// public:
// using A::g; // B::g is a public synonym for A::g
// };
public void test7_3_3s15() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// int i;
// namespace B {
// namespace C {
// int i;
// }
// using namespace A::B::C;
// void f1() {
// i = 5; // OK, C::i visible in B and hides A::i
// }
// }
// namespace D {
// using namespace B;
// using namespace C;
// void f2() {
// i = 5; // ambiguous, B::C::i or A::i?
// }
// }
// void f3() {
// i = 5; // uses A::i
// }
// }
// void f4() {
// i = 5; // illformed; neither i is visible
// }
public void test7_3_4s1() throws Exception {
String[] problems= {"i", "i"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// namespace M {
// int i;
// }
// namespace N {
// int i;
// using namespace M;
// }
// void f()
// {
// using namespace N;
// i = 7; // error: both M::i and N::i are visible
// }
public void test7_3_4s2a() throws Exception {
String[] problems= {"i"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// namespace A {
// int i;
// }
// namespace B {
// int i;
// int j;
// namespace C {
// namespace D {
// using namespace A;
// int j;
// int k;
// int a = i; // B::i hides A::i
// }
// using namespace D;
// int k = 89; // no problem yet
// int l = k; // ambiguous: C::k or D::k
// int m = i; // B::i hides A::i
// int n = j; // D::j hides B::j
// }
// }
public void test7_3_4s2b() throws Exception {
String[] problems= {"k"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// namespace D {
// int d1;
// void f(char);
// }
// using namespace D;
// int d1; // OK: no conflict with D::d1
// namespace E {
// int e;
// void f(int);
// }
// namespace D { // namespace extension
// int d2;
// using namespace E;
// void f(int);
// }
// void f()
// {
// d1++; //error: ambiguous ::d1 or D::d1?
// ::d1++; //OK
// D::d1++; //OK
// d2++; //OK: D::d2
// e++; //OK: E::e
// f(1); //error: ambiguous: D::f(int) or E::f(int)?
// f('a'); //OK: D::f(char)
// }
public void test7_3_4s5() throws Exception {
String[] problems= {"d1", "f"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// complex sqrt(complex); // C++ linkage by default
// extern "C" {
// double sqrt(double); // C linkage
// }
public void test7_5s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// extern "C" void f1(void(*pf)(int));
// // the name f1 and its function type have C language
// // linkage; pf is a pointer to a C function
// extern "C" typedef void FUNC();
// FUNC f2; // the name f2 has C++ language linkage and the
// // function's type has C language linkage
// extern "C" FUNC f3; // the name of function f3 and the function's type
// // have C language linkage
// void (*pf2)(FUNC*); // the name of the variable pf2 has C++ linkage and
// // the type of pf2 is pointer to C++ function that
// // takes one parameter of type pointer to C function
public void test7_5s4a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// extern "C" typedef void FUNC_c();
// class C {
// void mf1(FUNC_c*); // the name of the function mf1 and the member
// // function's type have C++ language linkage; the
// // parameter has type pointer to C function
// FUNC_c mf2; // the name of the function mf2 and the member
// // function's type have C++ language linkage
// static FUNC_c* q; // the name of the data member q has C++ language
// // linkage and the data member's type is pointer to
// // C function
// };
// extern "C" {
// class X {
// void mf(); // the name of the function mf and the member
// // function's type have C++ language linkage
// void mf2(void(*)()); // the name of the function mf2 has C++ language
// // linkage; the parameter has type pointer to
// // C function
// };
// }
public void test7_5s4b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// extern "C" int f();
// extern "C" int g() { return 1; }
// extern "C" int h();
// }
// namespace B {
// extern "C" int f(); // A::f and B::f refer
// // to the same function
// extern "C" int g() { return 1; } // illformed,
// // the function g
// // with C language linkage
// // has two definitions
// }
// int A::f() { return 98; } // definition for the function f
// // with C language linkage
// extern "C" int h() { return 97; }
// // definition for the function h
// // with C language linkage
// // A::h and ::h refer to the same function
public void test7_5s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// extern "C" double f();
// static double f(); // error
public void test7_5s7a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// extern "C" int i; // declaration
// extern "C" {
// int i; // definition
// }
public void test7_5s7b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// extern "C" static void f(); // error
public void test7_5s7c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int i;
// int *pi;
// int *p[3];
// int (*p3i)[3];
// int *f();
// int (*pf)(double);
public void test8_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// S(int);
// };
// void foo(double a)
// {
// S w(int(a)); // function declaration
// S x(int()); // function declaration
// S y((int)a); // object declaration
// S z = int(a); // object declaration
// }
public void test8_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T>
// struct S {
// T *p;
// };
// S<int()> x; // typeid
// S<int(1)> y; // expression (illformed)
public void test8_2s4() throws Exception {
IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 1);
NameCollector col = new NameCollector();
tu.accept(col);
assertInstance(col.getName(4), ICPPASTTemplateId.class);
assertInstance(((ICPPASTTemplateId)col.getName(4)).getTemplateArguments()[0], IASTTypeId.class);
final IASTName S_int_1 = col.getName(7);
assertInstance(S_int_1, ICPPASTTemplateId.class);
assertInstance(((ICPPASTTemplateId)S_int_1).getTemplateArguments()[0], IASTExpression.class);
assertInstance(S_int_1.getBinding(), IProblemBinding.class);
}
// void foo()
// {
// sizeof(int(1)); // expression
// // sizeof(int()); // typeid (illformed)
// }
public void test8_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void foo()
// {
// (int(1)); //expression
// // (int())1; //typeid (illformed)
// }
public void test8_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C { };
// void f(int(C)) { } // void f(int (*fp)(C c)) { }
// // not: void f(int C);
// int g(C);
// void foo() {
// f(1); //error: cannot convert 1 to function pointer
// f(g); //OK
// }
public void test8_2s7a() throws Exception { // TODO raised bug 90633
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, true, 1);
BindingAssertionHelper ba= new BindingAssertionHelper(code, true);
IFunction f= ba.assertNonProblem("f", 1, IFunction.class);
isTypeEqual(f.getType(), "void (int (*)(C))");
}
// class C { };
// void h(int *(C[10])); // void h(int *(*_fp)(C _parm[10]));
// // not: void h(int *C[10]);
public void test8_2s7b() throws Exception {
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, true, 0);
BindingAssertionHelper ba= new BindingAssertionHelper(code, true);
IFunction f= ba.assertNonProblem("h", 1, IFunction.class);
isTypeEqual(f.getType(), "void (int * (*)(C *))");
}
// namespace A {
// struct B {
// void f();
// };
// void A::B::f() { } // illformed: the declarator must not be
// // qualified with A::
// }
public void test8_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int unsigned i;
public void test8_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
// int i, *p, *const cp = &i;
//
// int f() {
// i = ci;
// *cp = ci;
// pc++;
// pc = cpc;
// pc = p;
// ppc = &pc;
// }
public void test8_3_1s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
// int i, *p, *const cp = &i;
// int f() {
// ci = 1; // error
// ci++; //error
// *pc = 2; // error
// cp = &ci; // error
// cpc++; //error
// p = pc; // error
// ppc = &p; // error
// }
public void test8_3_1s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// const int ci = 10, *pc = &ci, *const cpc = pc, **ppc;
// int i, *p, *const cp = &i;
// int f() {
// *ppc = &ci; // OK, but would make p point to ci ...
// *p = 5; // clobber ci
// }
public void test8_3_1s2c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int& A;
// const A aref = 3; // illformed;
// // nonconst reference initialized with rvalue
public void test8_3_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f(double& a) { a += 3.14; }
// void foo1() {
// double d = 0;
// f(d);
// }
//
// int v[20];
// int& g(int i) { return v[i]; }
// void foo2() {
// g(3) = 7;
// }
//
// struct link {
// link* next;
// };
// link* first;
// void h(link*& p) // p is a reference to pointer
// {
// p->next = first;
// first = p;
// p = 0;
// }
// void k()
// {
// link* q = new link;
// h(q);
// }
public void test8_3_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// void f(int);
// int a;
// };
// class Y;
//
// void f() {
// int X::* pmi = &X::a;
// void (X::* pmf)(int) = &X::f;
// double X::* pmd;
// char Y::* pmc;
// X obj;
// //...
// obj.*pmi = 7; // assign 7 to an integer
// // member of obj
// (obj.*pmf)(7); //call a function member of obj
// // with the argument 7
// }
public void test8_3_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int A[5], AA[2][3];
// typedef const A CA; // type is ''array of 5 const int''
// typedef const AA CAA; // type is ''array of 2 array of 3 const int''
public void test8_3_4s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// float fa[17], *afp[17];
// static int x3d[3][5][7];
public void test8_3_4s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int x[3][5];
public void test8_3_4s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int printf(const char*, ...);
// int f() {
// int a=1, b=0;
// printf("hello world");
// printf("a=%d b=%d", a, b);
// }
public void test8_3_5s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef void F();
// struct S {
// const F f; // illformed:
// // not equivalent to: void f() const;
// };
public void test8_3_5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// #define FILE int
// int fseek(FILE*, long, int);
public void test8_3_5s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef void F();
// F fv; // OK: equivalent to void fv();
// // F fv { } // illformed
// void fv() { } // OK: definition of fv
public void test8_3_5s7a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int FIC(int) const;
// FIC f; // illformed:
// //does not declare a member function
// struct S {
// FIC f; // OK
// };
// FIC S::*pm = &S::f; // OK
public void test8_3_5s7b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int i,
// *pi,
// f(),
// *fpi(int),
// (*pif)(const char*, const char*),
// (*fpif(int))(int);
public void test8_3_5s9a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int IFUNC(int);
// IFUNC* fpif(int);
public void test8_3_5s9b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void point(int = 3, int = 4);
// void f() {
// point(1,2); point(1); point();
// }
public void test8_3_6s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f(int, int);
// void f(int, int = 7);
// void h()
// {
// f(3); //OK, calls f(3, 7)
// void f(int = 1, int); // error: does not use default
// // from surrounding scope
// }
// void m()
// {
// void f(int, int); // has no defaults
// f(4); //error: wrong number of arguments
// void f(int, int = 5); // OK
// f(4); //OK, calls f(4, 5);
// void f(int, int = 5); // error: cannot redefine, even to
// // same value
// }
// void n()
// {
// f(6); //OK, calls f(6, 7)
// }
public void test8_3_6s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int a = 1;
// int f(int);
// int g(int x = f(a)); // default argument: f(::a)
// void h() {
// a = 2;
// {
// int a = 3;
// g(); // g(f(::a))
// }
// }
public void test8_3_6s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C {
// void f(int i = 3);
// void g(int i, int j = 99);
// };
// void C::f(int i = 3) // error: default argument already
// { } // specified in class scope
// void C::g(int i = 88, int j) // in this translation unit,
// { }
public void test8_3_6s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f()
// {
// int i;
// extern void g(int x = i); // error
// // ...
// }
public void test8_3_6s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// void f(A* p = this) { } // error
// };
public void test8_3_6s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int a;
// int f(int a, int b = a); // error: parameter a
// // used as default argument
// typedef int I;
// int g(float I, int b = I(2)); // error: parameter I found
// int h(int a, int b = sizeof(a)); // error, parameter a used
public void test8_3_6s9a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int b;
// class X {
// int a;
// int mem1(int i = a); // error: nonstatic member a
// // used as default argument
// int mem2(int i = b); // OK; use X::b
// static int b;
// };
public void test8_3_6s9b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(int = 0);
// void h()
// {
// int j = f(1);
// int k = f(); // OK, means f(0)
// }
// int (*p1)(int) = &f;
// int (*p2)() = &f; // error: type mismatch
public void test8_3_6s9c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// virtual void f(int a = 7);
// };
// struct B : public A {
// void f(int a);
// };
// void m()
// {
// B* pb = new B;
// A* pa = pb;
// pa->f(); //OK, calls pa->B::f(7)
// pb->f(); //error: wrong number of arguments for B::f()
// }
public void test8_3_6s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int max(int a, int b, int c)
// {
// int m = (a > b) ? a : b;
// return (m > c) ? m : c;
// }
public void test8_4s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
//class A {
// void a() & {}
// void b() && {}
//
// void c() const& {}
// void d() const&& {}
//
// void e() volatile & {}
// void f() volatile && {}
//
// void g() volatile const& {}
// void h() volatile const&& {}
//};
public void test8s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void print(int a, int)
// {
// //printf("a = %d",a);
// }
public void test8_4s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int a;
// struct X {
// static int a;
// static int b;
// };
// int X::a = 1;
// int X::b = a; // X::b = X::a
public void test8_5s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// int x;
// struct B {
// int i;
// int j;
// } b;
// } a = { 1, { 2, 3 } };
public void test8_5_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int x[] = { 1, 3, 5 };
public void test8_5_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// int i;
// static int s;
// int j;
// } a = { 1, 2 };
public void test8_5_1s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// char cv[4] = { 'a', 's', 'd', 'f', 0 }; // error
public void test8_5_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S { int a; char* b; int c; };
// S ss = { 1, "asdf" };
public void test8_5_1s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S { };
// struct A {
// S s;
// int i;
// } a = { { } , 3 };
public void test8_5_1s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int x[2][2] = { 3, 1, 4, 2 };
// float y[4][3] = {
// { 1 }, { 2 }, { 3 }, { 4 }
// };
public void test8_5_1s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// float y[4][3] = {
// { 1, 3, 5 },
// { 2, 4, 6 },
// { 3, 5, 7 },
// };
public void test8_5_1s11a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// float y[4][3] = {
// 1, 3, 5, 2, 4, 6, 3, 5, 7
// };
public void test8_5_1s11b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// int i;
// operator int();
// };
// struct B {
// A a1, a2;
// int z;
// };
// A a;
// B b = { 4, a, a };
public void test8_5_1s12() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// union u { int a; char* b; };
// u a = { 1 };
// u b = a;
// u c = 1; // error
// u d = { 0, "asdf" }; // error
// u e = { "asdf" }; // error
public void test8_5_1s15() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// char msg[] = "Syntax error on line %s";
public void test8_5_2s1() throws Exception {
// raised bug 90647
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// char cv[4] = "asdf"; // error
public void test8_5_2s2() throws Exception {
// we do not check the size of an array, which is ok.
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int& r1; // error: initializer missing
// extern int& r2; // OK
public void test8_5_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// Note: the examples for 8.5.3/5 are written slightly differently
// than they appear in the standard. In the standard, the examples
// demonstrate the rules with variable initialiation, but CDT doesn't
// currently issue problem bindings for variable initialization,
// so in the tests the examples are rewritten to use function calls.
// void f1(double);
// void f2(double&);
// void f3(const double&);
// struct A { };
// struct B : public A { operator int&(); } b;
// void f4(A&);
// void f5(const A&);
// void f6(int&);
// int main() {
// f1(2.0);
// double d;
// f2(d);
// f3(d);
// f4(b);
// f5(b);
// f6(B());
// }
public void test8_5_3s5a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f1(double&);
// void f2(double&);
// int main() {
// f1(2.0); // error: not an lvalue and reference not const
// int i = 2;
// f2(i); // error: type mismatch and reference not const
// }
public void test8_5_3s5b() throws Exception {
BindingAssertionHelper helper = getAssertionHelper(ParserLanguage.CPP);
helper.assertProblem("f1(2", "f1");
helper.assertProblem("f2(i", "f2");
}
// struct A { };
// struct B : public A { } b;
// extern B f();
// void f1(const A&);
// void f2(A&&);
// struct X {
// operator B();
// operator int&();
// } x;
// void f3(int&&);
// void f4(B&&);
// int main() {
// f1(f()); // bound to the A subobject of the B rvalue
// f2(f()); // same as above
// f1(x); // bound to the A subobject of the result of the conversion
// f3(static_cast<int&&>(i)); // bound directly to i
// f4(x); // bound directly to the result of operator B
// f3(X()); // error: lvalue-to-rvalue conversion applied to result of operator int&
// }
public void test8_5_3s5c() throws Exception {
BindingAssertionHelper helper = getAssertionHelper(ParserLanguage.CPP);
helper.assertNonProblem("f1(f", "f1");
helper.assertNonProblem("f2(f", "f2");
helper.assertNonProblem("f1(x", "f1");
helper.assertNonProblem("f3(s", "f3");
helper.assertNonProblem("f4(x", "f4");
helper.assertProblem("f3(X", "f3");
}
// void f1(const double&);
// void f2(double&&);
// void f3(const int&);
// int main() {
// f1(2);
// f2(2);
// const volatile int cvi = 1;
// f3(cvi); // error: type qualifiers dropped
// double d;
// int i;
// f2(d); // error: copying lvalue of related type
// f2(i);
// }
public void test8_5_3s5d() throws Exception {
BindingAssertionHelper helper = getAssertionHelper(ParserLanguage.CPP);
helper.assertNonProblem("f1(2", "f1");
helper.assertNonProblem("f2(2", "f2");
helper.assertProblem("f3(cv", "f3");
helper.assertProblem("f2(d)", "f2");
helper.assertNonProblem("f2(i", "f2");
}
// struct X { int a; };
// struct Y { int a; };
// X a1;
// Y a2;
// int a3;
// void test() {
// a1 = a2; // error: Y assigned to X
// a1 = a3; // error: int assigned to X
// }
// int f(X);
// int f(Y);
// struct S { int a; };
// struct S { int a; }; // error, double definition
public void test9_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct stat {
// // ...
// };
// stat gstat; // use plain stat to
// // define variable
// int stat(struct stat*); // redeclare stat as function
// void f()
// {
// struct stat* ps; // struct prefix needed
// // to name struct stat
// // ...
// stat(ps); //call stat()
// // ...
// }
public void test9_1s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct s { int a; };
// void g()
// {
// struct s; // hide global struct s
// // with a local declaration
// s* p; // refer to local struct s
// struct s { char* p; }; // define local struct s
// struct s; // redeclaration, has no effect
// }
public void test9_1s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Vector;
// class Matrix {
// // ...
// friend Vector operator*(Matrix&, Vector&);
// };
// class Vector {
// // ...
// friend Vector operator*(Matrix&, Vector&);
// };
public void test9_1s2c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct s { int a; };
// void g(int s)
// {
// struct s* p = new struct s; // global s
// p->a = s; // local s
// }
public void test9_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A * A;
public void test9_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct tnode {
// char tword[20];
// int count;
// tnode *left;
// tnode *right;
// };
// tnode s, *sp;
public void test9_2s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// typedef int T;
// static T count;
// void f(T);
// };
// void X::f(T t = count) { }
public void test9_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef void fv(void);
// typedef void fvc(void) const;
// struct S {
// fv memfunc1; // equivalent to: void memfunc1(void);
// void memfunc2();
// fvc memfunc3; // equivalent to: void memfunc3(void) const;
// };
// fv S::* pmfv1 = &S::memfunc1;
// fv S::* pmfv2 = &S::memfunc2;
// fvc S::* pmfv3 = &S::memfunc3;
public void test9_3s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct tnode {
// char tword[20];
// int count;
// tnode *left;
// tnode *right;
// void set(char*, tnode* l, tnode* r);
// };
// void tnode::set(char* w, tnode* l, tnode* r)
// {
// count = strlen(w)+1;
// if (sizeof(tword)<=count)
// perror("tnode string too long");
// strcpy(tword,w);
// left = l;
// right = r;
// }
// void f(tnode n1, tnode n2)
// {
// n1.set("abc",&n2,0);
// n2.set("def",0,0);
// }
public void test9_3_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct X {
// void g() const;
// void h() const volatile;
// };
public void test9_3_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct s {
// int a;
// int f() const;
// int g() { return a++; }
// int h() const { return a++; } // error
// };
// int s::f() const { return a; }
public void test9_3_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct s {
// int a;
// int f() const;
// int g() { return a++; }
// };
// int s::f() const { return a; }
//
// void k(s& x, const s& y)
// {
// x.f();
// x.g();
// y.f();
// y.g(); //error
// }
public void test9_3_2s4() throws Exception {
String[] problems= {"g"};
final String code = getAboveComment();
IASTTranslationUnit tu= parse(code, ParserLanguage.CPP, problems);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
bh.assertNonProblem("g();", 1);
bh.assertProblem("g(); //error", 1);
}
// class process {
// public:
// static void reschedule();
// };
// process& g();
// void f()
// {
// process::reschedule(); // OK: no object necessary
// g().reschedule(); // g() is called
// }
public void test9_4s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int g();
// struct X {
// static int g();
// };
// struct Y : X {
// static int i;
// };
// int Y::i = g(); // equivalent to Y::g();
public void test9_4s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class process {
// static process* run_chain;
// static process* running;
// };
// process* process::running = get_main();
// process* process::run_chain = running;
public void test9_4_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void f()
// {
// union { int a; char* p; };
// a = 1;
// // ...
// p = "Jennifer";
// // ...
// }
public void test9_5s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// union { int aa; char* p; } obj, *ptr = &obj;
// aa = 1; // error
// ptr->aa = 1; // OK
// }
public void test9_5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// enum BOOL { f=0, t=1 };
// struct A {
// BOOL b:1;
// };
// A a;
// void f() {
// a.b = t;
// if (a.b == t) // shall yield true
// { }
// }
public void test9_6s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int x;
// int y;
// class enclose {
// public:
// int x;
// static int s;
// class inner {
// void f(int i)
// {
// int a = sizeof(x); // error: refers to enclose::x
// x = i; // error: assign to enclose::x
// s = i; // OK: assign to enclose::s
// ::x = i; // OK: assign to global x
// y = i; // OK: assign to global y
// }
// void g(enclose* p, int i)
// {
// p>
// x = i; // OK: assign to enclose::x
// }
// };
// };
// inner* p = 0; // error: inner not in scope
public void test9_7s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class enclose {
// public:
// class inner {
// static int x;
// void f(int i);
// };
// };
// int enclose::inner::x = 1;
// void enclose::inner::f(int i) { }
public void test9_7s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class E {
// class I1; // forward declaration of nested class
// class I2;
// class I1 {}; // definition of nested class
// };
// class E::I2 {}; // definition of nested class
public void test9_7s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int x;
// void f()
// {
// static int s ;
// int x;
// extern int g();
// struct local {
// int g() { return x; } // error: x is auto
// int h() { return s; } // OK
// int k() { return ::x; } // OK
// int l() { return g(); } // OK
// };
// // ...
// }
// local* p = 0; // error: local not in scope
public void test9_8s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class X {
// public:
// typedef int I;
// class Y { /* ... */ };
// I a;
// };
// I b; // error
// Y c; // error
// X::Y d; // OK
// X::I e; // OK
public void test9_9s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class Base {
// public:
// int a, b, c;
// };
// class Derived : public Base {
// public:
// int b;
// };
// class Derived2 : public Derived {
// public:
// int c;
// };
public void test10s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A { };
// class B { };
// class C { };
// class D : public A, public B, public C { };
public void test10_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X { };
// class Y : public X, public X { }; // illformed
public void test10_1s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class L { public: int next; };
// class A : public L { };
// class B : public L { };
// class C : public A, public B { void f(); }; // wellformed
// class D : public A, public L { void f(); }; // wellformed
//
public void test10_1s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// public:
// int a;
// int (*b)();
// int f();
// int f(int);
// int g();
// };
// class B {
// int a;
// int b();
// public:
// int f();
// int g;
// int h();
// int h(int);
// };
// class C : public A, public B {};
// void g(C* pc)
// {
// pc->a = 1; // error: ambiguous: A::a or B::a
// pc->b(); //error: ambiguous: A::b or B::b
// pc->f(); //error: ambiguous: A::f or B::f
// pc->f(1); //error: ambiguous: A::f or B::f
// pc->g(); //error: ambiguous: A::g or B::g
// pc->g = 1; // error: ambiguous: A::g or B::g
// pc->h(); //OK
// pc->h(1); //OK
// }
public void test10_2s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct U { static int i; };
// struct V : U { };
// struct W : U { using U::i; };
// struct X : V, W { void foo(); };
// void X::foo() {
// i; //finds U::i in two ways: as W::i and U::i in V
// // no ambiguity because U::i is static
// }
public void test10_2s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// public:
// int f();
// };
// class B {
// public:
// int f();
// };
// class C : public A, public B {
// int f() { return A::f() + B::f(); }
// };
public void test10_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class V { public: int v; };
// class A {
// public:
// int a;
// static int s;
// enum { e };
// };
// class B : public A, public virtual V {};
// class C : public A, public virtual V {};
// class D : public B, public C { };
// void f(D* pd)
// {
// pd->v++; //OK: only one v (virtual)
// pd->s++; //OK: only one s (static)
// int i = pd>
// e; // OK: only one e (enumerator)
// pd->a++; //error, ambiguous: two as in D
// }
public void test10_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class V { public: int f(); int x; };
// class W { public: int g(); int y; };
// class B : public virtual V, public W
// {
// public:
// int f(); int x;
// int g(); int y;
// };
// class C : public virtual V, public W { };
// class D : public B, public C { void glorp(); };
public void test10_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class V { };
// class A { };
// class B : public A, public virtual V { };
// class C : public A, public virtual V { };
// class D : public B, public C { };
// void g()
// {
// D d;
// B* pb = &d;
// A* pa = &d; // error, ambiguous: C's A or B's A?
// V* pv = &d; // OK: only one V subobject
// }
public void test10_2s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// virtual void f();
// };
// struct B : virtual A {
// virtual void f();
// };
// struct C : B , virtual A {
// using A::f;
// };
// void foo() {
// C c;
// c.f(); //calls B::f, the final overrider
// c.C::f(); //calls A::f because of the usingdeclaration
// }
public void test10_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B {};
// class D : private B { friend class Derived; };
// struct Base {
// virtual void vf1();
// virtual void vf2();
// virtual void vf3();
// virtual B* vf4();
// virtual B* vf5();
// void f();
// };
// struct No_good : public Base {
// D* vf4(); // error: B (base class of D) inaccessible
// };
// class A;
// struct Derived : public Base {
// void vf1(); // virtual and overrides Base::vf1()
// void vf2(int); // not virtual, hides Base::vf2()
// char vf3(); // error: invalid difference in return type only
// D* vf4(); // OK: returns pointer to derived class
// A* vf5(); // error: returns pointer to incomplete class
// void f();
// };
// void g()
// {
// Derived d;
// Base* bp = &d; // standard conversion:
// // Derived* to Base*
// bp->vf1(); //calls Derived::vf1()
// bp->vf2(); //calls Base::vf2()
// bp->f(); //calls Base::f() (not virtual)
// B* p = bp->vf4(); // calls Derived::pf() and converts the
// // result to B*
// Derived* dp = &d;
// D* q = dp->vf4(); // calls Derived::pf() and does not
// // convert the result to B*
// dp->vf2(); //illformed: argument mismatch
// }
public void test10_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A {
// virtual void f();
// };
// struct B1 : A { // note nonvirtual derivation
// void f();
// };
// struct B2 : A {
// void f();
// };
// struct D : B1, B2 { // D has two separate A subobjects
// };
// void foo()
// {
// D d;
// // A* ap = &d; // would be illformed:ambiguous
// B1* b1p = &d;
// A* ap = b1p;
// D* dp = &d;
// ap->f(); //calls D::B1::f
// dp->f(); //illformed: ambiguous
// }
public void test10_3s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A {
// virtual void f();
// };
// struct VB1 : virtual A { // note virtual derivation
// void f();
// };
// struct VB2 : virtual A {
// void f();
// };
// struct Error : VB1, VB2 { // illformed
// };
// struct Okay : VB1, VB2 {
// void f();
// };
public void test10_3s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct VB1a : virtual A { // does not declare f
// };
// struct Da : VB1a, VB2 {
// };
// void foe()
// {
// VB1a* vb1ap = new Da;
// vb1ap->f(); //calls VB2::f
// }
public void test10_3s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class B { public: virtual void f(); };
// class D : public B { public: void f(); };
// void D::f() { B::f(); }
public void test10_3s12() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class point { };
// class shape { // abstract class
// point center;
// // ...
// public:
// point where() { return center; }
// void move(point p) { center=p; draw(); }
// virtual void rotate(int) = 0; // pure virtual
// virtual void draw() = 0; // pure virtual
// // ...
// };
public void test10_4s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// Not legal C++
// // public void test10_4s2b() throws Exception {
// StringBuilder buffer = new StringBuilder();
// buffer.append("struct C {\n"); //$NON-NLS-1$
// buffer.append("virtual void f() { }=0; // illformed\n"); //$NON-NLS-1$
// buffer.append("};\n"); //$NON-NLS-1$
// parse(getAboveComment(), ParserLanguage.CPP, true, 0);
// }
// shape x; // error: object of abstract class
// shape* p; // OK
// shape f(); // error
// void g(shape); // error
// shape& h(shape&); // OK
public void test10_4s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class ab_circle : public shape {
// int radius;
// public:
// void rotate(int) {}
// // ab_circle::draw() is a pure virtual
// };
public void test10_4s4a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class circle : public shape {
// int radius;
// public:
// void rotate(int) {}
// void draw(); // a definition is required somewhere
// };
public void test10_4s4b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class X {
// int a; // X::a is private by default
// };
// struct S {
// int a; // S::a is public by default
// };
public void test11s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A
// {
// class B { };
// public:
// typedef B BB;
// };
// void f()
// {
// A::BB x; // OK, typedef name A::BB is public
// A::B y; // access error, A::B is private
// }
public void test11s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// typedef int I; // private member
// I f();
// friend I g(I);
// static I x;
// };
// A::I A::f() { return 0; }
// A::I g(A::I p = A::x);
// A::I g(A::I p) { return 0; }
// A::I A::x = 0;
public void test11s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class D {
// class E {
// static int m;
// };
// };
// int D::E::m = 1; // OK, no access error on private E
public void test11s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// int a; // X::a is private by default: class used
// public:
// int b; // X::b is public
// int c; // X::c is public
// };
public void test11_1s1a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// int a; // S::a is public by default: struct used
// protected:
// int b; // S::b is protected
// private:
// int c; // S::c is private
// public:
// int d; // S::d is public
// };
public void test11s1b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// class A;
// private:
// class A { }; // error: cannot change access
// };
public void test11_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B { };
// class D1 : private B { };
// class D2 : public B { };
// class D3 : B { }; // B private by default
// struct D4 : public B { };
// struct D5 : private B { };
// struct D6 : B { }; // B public by default
// class D7 : protected B { };
// struct D8 : protected B { };
public void test11_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B {
// public:
// int mi; // nonstatic member
// static int si; // static member
// };
// class D : private B {
// };
// class DD : public D {
// void f();
// };
// void DD::f() {
// mi = 3; // error: mi is private in D
// si = 3; // error: si is private in D
// B b;
// b.mi = 3; // OK (b.mi is different from this->mi)
// b.si = 3; // OK (b.si is different from this->si)
// B::si = 3; // OK
// B* bp1 = this; // error: B is a private base class
// B* bp2 = (B*)this; // OK with cast
// bp2->mi = 3; // OK: access through a pointer to B.
// }
public void test11_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B;
// class A {
// private:
// int i;
// friend void f(B*);
// };
// class B : public A { };
// void f(B* p) {
// p->i = 1; // OK: B* can be implicitly cast to A*,
// // and f has access to i in A
// }
public void test11_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// int a;
// friend void friend_set(X*, int);
// public:
// void member_set(int);
// };
// void friend_set(X* p, int i) { p->a = i; }
// void X::member_set(int i) { a = i; }
// void f()
// {
// X obj;
// friend_set(&obj,10);
// obj.member_set(10);
// }
public void test11_4s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// class B { };
// friend class X;
// };
// class X : A::B { // illformed:
// //A::B cannot be accessed
// // in the baseclause for X
// A::B mx; // OK: A::B used to declare member of X
// class Y : A::B { // OK: A::B used to declare member of X
// A::B my; // illformed: A::B cannot be accessed
// // to declare members of nested class of X
// };
// };
public void test11_4s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// enum { a=100 };
// friend class Y;
// };
// class Y {
// int v[X::a]; // OK, Y is a friend of X
// };
// class Z {
// int v[X::a]; // error: X::a is private
// };
public void test11_4s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Y {
// friend char* X::foo(int);
// // ...
// };
public void test11_4s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class M {
// friend void f() { } // definition of global f, a friend of M,
// // not the definition of a member function
// };
public void test11_4s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// friend class B;
// int a;
// };
// class B {
// friend class C;
// };
// class C {
// void f(A* p)
// {
// p->a++; //error: C is not a friend of A
// // despite being a friend of a friend
// }
// };
// class D : public B {
// void f(A* p)
// {
// p->a++; //error: D is not a friend of A
// // despite being derived from a friend
// }
// };
public void test11_4s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X;
// void a();
// void f() {
// class Y;
// extern void b();
// class A {
// friend class X; // OK, but X is a local class, not ::X
// friend class Y; // OK
// friend class Z; // OK, introduces local class Z
// friend void a(); // error, ::a is not considered
// friend void b(); // OK
// friend void c(); // error
// };
// X *px; // OK, but ::X is found
// Z *pz; // error, no Z is found
// }
public void test11_4s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class B {
// protected:
// int i;
// static int j;
// };
// class D1 : public B {
// };
// class D2 : public B {
// friend void fr(B*,D1*,D2*);
// void mem(B*,D1*);
// };
// void fr(B* pb, D1* p1, D2* p2)
// {
// pb->i = 1; // illformed
// p1->i = 2; // illformed
// p2->i = 3; // OK (access through a D2)
// p2->B::i = 4; // OK (access through a D2, even though
// // naming class is B)
// int B::* pmi_B = &B::i; // illformed
// int B::* pmi_B2 = &D2::i; // OK (type of &D2::i is int B::*)
// B::j = 5; // OK (because refers to static member)
// D2::j =6; // OK (because refers to static member)
// }
// void D2::mem(B* pb, D1* p1)
// {
// pb->i = 1; // illformed
// p1->i = 2; // illformed
// i = 3; // OK (access through this)
// B::i = 4; // OK (access through this, qualification ignored)
// int B::* pmi_B = &B::i; // illformed
// int B::* pmi_B2 = &D2::i; // OK
// j = 5; // OK (because j refers to static member)
// B::j = 6; // OK (because B::j refers to static member)
// }
// void g(B* pb, D1* p1, D2* p2)
// {
// pb->i = 1; // illformed
// p1->i = 2; // illformed
// p2->i = 3; // illformed
// }
public void test11_5s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B {
// public:
// virtual int f();
// };
// class D : public B {
// private:
// int f();
// };
// void f()
// {
// D d;
// B* pb = &d;
// D* pd = &d;
// pb->f(); //OK: B::f() is public,
// // D::f() is invoked
// pd->f(); //error: D::f() is private
// }
public void test11_6s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class W { public: void f(); };
// class A : private virtual W { };
// class B : public virtual W { };
// class C : public A, public B {
// void f() { W::f(); } // OK
// };
public void test11_7s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class E {
// int x;
// class B { };
// class I {
// B b; // error: E::B is private
// int y;
// void f(E* p, int i)
// {
// p->x = i; // error: E::x is private
// }
// };
// int g(I* p)
// {
// return p->y; // error: I::y is private
// }
// };
public void test11_8s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C {
// class A { };
// A *p; // OK
// class B : A // OK
// {
// A *q; // OK because of injection of name A in A
// C::A *r; // error, C::A is inaccessible
// B *s; // OK because of injection of name B in B
// C::B *t; // error, C::B is inaccessible
// };
// };
public void test11_8s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C {
// public:
// C(); //declares the constructor
// };
// C::C() { } // defines the constructor
public void test12_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct C;
// void no_opt(C*);
// struct C {
// int c;
// C() : c(0) { no_opt(this); }
// };
// const C cobj;
// void no_opt(C* cptr) {
// int i = cobj.c * 100; // value of cobj.c is unspecified
// cptr->c = 1;
// cout << cobj.c * 100 // value of cobj.c is unspecified
// << '\
// ';
// }
public void test12_1s15() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class X {
// // ...
// public:
// // ...
// X(int);
// X(const X&);
// ~X();
// };
// X f(X);
// void g()
// {
// X a(1);
// X b = f(X(2));
// a = f(a);
// }
public void test12_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class C {
// // ...
// public:
// C();
// C(int);
// friend C operator+(const C&, const C&);
// ~C();
// };
// C obj1;
// const C& cr = C(16)+C(23);
// C obj2;
public void test12_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// // ...
// public:
// operator int();
// };
// class Y {
// // ...
// public:
// operator X();
// };
// Y a;
// int b = a; // error:
// // a.operator X().operator int() not tried
// int c = X(a); // OK: a.operator X().operator int()
public void test12_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// // ...
// operator int();
// };
// class Y : public X {
// public:
// // ...
// operator char();
// };
// void f(Y& a)
// {
// if (a) { // illformed:
// // X::operator int() or Y::operator char()
// // ...
// }
// }
public void test12_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// // ...
// public:
// X(int);
// X(const char*, int =0);
// };
// void f(X arg)
// {
// X a = 1; // a = X(1)
// X b = "Jessie"; // b = X("Jessie",0)
// a = 2; // a = X(2)
// f(3); // f(X(3))
// }
public void test12_3_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Z {
// public:
// explicit Z();
// explicit Z(int);
// // ...
// };
// Z a; // OK: defaultinitialization performed
// Z a1 = 1; // error: no implicit conversion
// Z a3 = Z(1); // OK: direct initialization syntax used
// Z a2(1); // OK: direct initialization syntax used
// Z* p = new Z(1); // OK: direct initialization syntax used
// Z a4 = (Z)1; // OK: explicit cast used
// Z a5 = static_cast<Z>(1); // OK: explicit cast used
public void test12_3_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// // ...
// public:
// operator int();
// };
// void f(X a)
// {
// int i = int(a);
// i = (int)a;
// i = a;
// }
public void test12_3_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void g(X a, X b)
// {
// int i = (a) ? 1+a : 0;
// int j = (a&&b) ? a+b : i;
// if (a) { // ...
// }
// }
public void test12_3_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct B {
// virtual ~B() { }
// };
// struct D : B {
// ~D() { }
// };
// D D_object;
// typedef B B_alias;
// B* B_ptr = &D_object;
// void f() {
// D_object.B::~B(); //1 // calls B's destructor
// B_ptr->~B(); //2 // calls D's destructor
// B_ptr->~B_alias(); //3 // calls D's destructor
// B_ptr->B_alias::~B(); //4 // calls B's destructor
// B_ptr->B_alias::~B_alias(); //5 // error, no B_alias in class B
// }
public void test12_4s12() throws Exception {
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, false, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPFunction dtor= bh.assertNonProblem("~B() {", 2);
ICPPFunction d= bh.assertNonProblem("~B(); //1", 2);
assertSame(dtor, d);
d= bh.assertNonProblem("~B(); //2", 2);
assertSame(dtor, d);
d= bh.assertNonProblem("~B_alias(); //3", 8);
assertSame(dtor, d);
d= bh.assertNonProblem("~B(); //4", 2);
assertSame(dtor, d);
bh.assertProblem("~B_alias(); //5", 8);
}
// void* operator new(size_t, void* p) { return p; }
// struct X {
// // ...
// X(int);
// ~X();
// };
// void f(X* p);
// void g() // rare, specialized use:
// {
// char* buf = new char[sizeof(X)];
// X* p = new(buf) X(222); // use buf[] and initialize
// f(p);
// p->X::~X(); //cleanup
// }
public void test12_4s13() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class Arena;
// struct B {
// void* operator new(size_t, Arena*);
// };
// struct D1 : B {
// };
// Arena* ap;
// void foo(int i)
// {
// new (ap) D1; // calls B::operator new(size_t, Arena*)
// new D1[i]; // calls ::operator new[](size_t)
// new D1; // illformed: ::operator new(size_t) hidden
// }
public void test12_5s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class X {
// // ...
// void operator delete(void*);
// void operator delete[](void*, size_t);
// };
// class Y {
// // ...
// void operator delete(void*, size_t);
// void operator delete[](void*);
// };
public void test12_5s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class complex {
// // ...
// public:
// complex();
// complex(double);
// complex(double,double);
// // ...
// };
// complex sqrt(complex,complex);
// int foo() {
// complex a(1); // initialize by a call of
// // complex(double)
// complex b = a; // initialize by a copy of a
// complex c = complex(1,2); // construct complex(1,2)
// // using complex(double,double)
// // copy it into c
// complex d = sqrt(b,c); // call sqrt(complex,complex)
// // and copy the result into d
// complex e; // initialize by a call of
// // complex()
// complex f = 3; // construct complex(3) using
// // complex(double)
// // copy it into f
// complex g = { 1, 2 }; // error; constructor is required
// }
public void test12_6_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class complex {
// // ...
// public:
// complex();
// complex(double);
// complex(double,double);
// // ...
// };
// complex v[6] = { 1,complex(1,2),complex(),2 };
// class X {
// public:
// int i;
// float f;
// complex c;
// } x = { 99, 88.8, 77.7 };
public void test12_6_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A { A(); };
// typedef A global_A;
// struct B { };
// struct C: public A, public B { C(); };
// C::C(): global_A() { } // meminitializer for base A
public void test12_6_2s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A { A(); };
// struct B: public virtual A { };
// struct C: public A, public B { C(); };
// C::C(): A() { } // illformed: which A?
public void test12_6_2s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct B1 { B1(int); };
// struct B2 { B2(int); };
// struct D : B1, B2 {
// D(int);
// B1 b;
// const int c;
// };
// D::D(int a) : B2(a+1), B1(a+2), c(a+3), b(a+4)
// { }
// D d(10);
public void test12_6_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class V {
// public:
// V();
// V(int);
// // ...
// };
// class A : public virtual V {
// public:
// A();
// A(int);
// // ...
// };
// class B : public virtual V {
// public:
// B();
// B(int);
// // ...
// };
// class C : public A, public B, private virtual V {
// public:
// C();
// C(int);
// // ...
// };
// A::A(int i) : V(i) { }
// B::B(int i) { }
// C::C(int i) { }
// V v(1); // use V(int)
// A a(2); // use V(int)
// B b(3); // use V()
// C c(4); // use V()
public void test12_6_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// int a;
// int b;
// int i;
// int j;
// public:
// const int& r;
// X(int i): r(a), b(i), i(i), j(this->i) {}
// };
public void test12_6_2s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A {
// public:
// A(int);
// };
// class B : public A {
// int j;
// public:
// int f();
// B() : A(f()), // undefined: calls member function
// // but base A not yet initialized
// j(f()) { } // welldefined: bases are all initialized
// };
// class C {
// public:
// C(int);
// };
// class D : public B, C {
// int i;
// public:
// D() : C(f()), // undefined: calls member function
// // but base C not yet initialized
// i(f()) {} // welldefined: bases are all initialized
// };
public void test12_6_2s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X { int i; };
// struct Y : X { };
// struct A { int a; };
// struct B : public A { int j; Y y; };
// extern B bobj;
// B* pb = &bobj; // OK
// int* p1 = &bobj.a; // undefined, refers to base class member
// int* p2 = &bobj.y.i; // undefined, refers to member's member
// A* pa = &bobj; // undefined, upcast to a base class type
// B bobj; // definition of bobj
// extern X xobj;
// int* p3 = &xobj.i; // OK, X is a POD class
// X xobj;
public void test12_7s1_a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct W { int j; };
// struct X : public virtual W { };
// struct Y {
// int *p;
// X x;
// Y() : p(&x.j) // undefined, x is not yet constructed
// { }
// };
public void test12_7s1_b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class V {
// public:
// virtual void f();
// virtual void g();
// };
// class A : public virtual V {
// public:
// virtual void f();
// };
// class B : public virtual V {
// public:
// virtual void g();
// B(V*, A*);
// };
// class D : public A, B {
// public:
// virtual void f();
// virtual void g();
// D() : B((A*)this, this) { }
// };
// B::B(V* v, A* a) {
// f(); //calls V::f, not A::f
// g(); //calls B::g, not D::g
// v->g(); // v is base of B, the call is welldefined, calls B::g
// a->f(); //undefined behavior, a's type not a base of B
// }
public void test12_7s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class V {
// public:
// virtual void f();
// };
// class A : public virtual V { };
// class B : public virtual V {
// public:
// B(V*, A*);
// };
// class D : public A, B {
// public:
// D() : B((A*)this, this) { }
// };
// B::B(V* v, A* a) {
// typeid(*this); // type_info for B
// typeid(*v); //welldefined: *v has type V, a base of B
// // yields type_info for B
// typeid(*a); //undefined behavior: type A not a base of B
// dynamic_cast<B*>(v); // welldefined: v of type V*, V base of B
// // results in B*
// dynamic_cast<B*>(a); // undefined behavior,
// // a has type A*, A not a base of B
// }
public void test12_7s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// // ...
// public:
// X(int);
// X(const X&, int = 1);
// };
// X a(1); // calls X(int);
// X b(a, 0); // calls X(const X&, int);
// X c = b; // calls X(const X&, int);
public void test12_8s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// // ...
// public:
// X(const X&);
// X(X&); //OK
// };
public void test12_8s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// X(); //default constructor
// X(X&); //copy constructor with a nonconst parameter
// };
// const X cx;
// X x = cx; // error - X::X(X&) cannot copy cx into x
public void test12_8s2c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// template<typename T> S(T);
// };
// S f();
// void g() {
// S a( f() ); // does not instantiate member template
// }
public void test12_8s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void h(int());
// void h(int (*)()); // redeclaration of h(int())
// void h(int x()) { } // definition of h(int())
// void h(int (*x)()) { } // illformed: redefinition of h(int())
public void test12_8s3d() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 1);
}
// struct X {
// X(const X&, int);
// };
public void test12_8s4a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// X(const X&, int);
// };
// X::X(const X& x, int i =0) { }
public void test12_8s4b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// X();
// X& operator=(X&);
// };
// const X cx;
// X x;
// void f() {
// x = cx; // error:
// // X::operator=(X&) cannot assign cx into x
// }
public void test12_8s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct V { };
// struct A : virtual V { };
// struct B : virtual V { };
// struct C : B, A { };
public void test12_8s13() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Thing {
// public:
// Thing();
// ~Thing();
// Thing(const Thing&);
// Thing operator=(const Thing&);
// void fun();
// };
// Thing f() {
// Thing t;
// return t;
// }
// Thing t2 = f();
public void test12_8s15() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// double abs(double);
// int abs(int);
// int foo() {
// abs(1); //call abs(int);
// abs(1.0); //call abs(double);
// }
public void test13s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// static void f();
// void f(); // illformed
// void f() const; // illformed
// void f() const volatile; // illformed
// void g();
// void g() const; // OK: no static g
// void g() const volatile; // OK: no static g
// };
public void test12_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int Int;
// void f(int i);
// void f(Int i); // OK: redeclaration of f(int)
// void f(int i) { }
// void f(Int i) { } // error: redefinition of f(int)
public void test12_1s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 1);
}
// enum E { a };
// void f(int i) { }
// void f(E i) { }
public void test12_1s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(char*);
// int f(char[]); // same as f(char*);
// int f(char[7]); // same as f(char*);
// int f(char[9]); // same as f(char*);
// int g(char(*)[10]);
// int g(char[5][10]); // same as g(char(*)[10]);
// int g(char[7][10]); // same as g(char(*)[10]);
// int g(char(*)[20]); // different from g(char(*)[10]);
public void test12_1s3c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef const int cInt;
// int f (int);
// int f (const int); // redeclaration of f(int)
// int f (int) { } // definition of f(int)
// int f (cInt) { } // error: redefinition of f(int)
public void test12_8s3e() throws Exception {
String[] problems= {"f"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// void f (int i, int j);
// void f (int i, int j = 99); // OK: redeclaration of f(int, int)
// void f (int i = 88, int j); // OK: redeclaration of f(int, int)
// void f (); // OK: overloaded declaration of f
// void prog ()
// {
// f (1, 2); // OK: call f(int, int)
// f (1); // OK: call f(int, int)
// f (); // Error: f(int, int) or f()?
// }
public void test12_8s3f() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class B {
// public:
// int f(int);
// };
// class D : public B {
// public:
// int f(char*);
// };
public void test13_2s1a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B {
// public:
// int f(int);
// };
// class D : public B {
// public:
// int f(char*);
// };
// void h(D* pd)
// {
// pd->f(1); //error:
// // D::f(char*) hides B::f(int)
// pd->B::f(1); //OK
// pd->f("Ben"); //OK, calls D::f
// }
public void test13_2s1b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int f(char*);
// void g()
// {
// extern int f(int);
// f("asdf"); //error: f(int) hides f(char*)
// // so there is no f(char*) in this scope
// }
// void caller ()
// {
// extern void callee(int, int);
// {
// extern void callee(int); // hides callee(int, int)
// callee(88, 99); // error: only callee(int) in scope
// }
// }
public void test13_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class buffer {
// private:
// char* p;
// int size;
// protected:
// buffer(int s, char* store) { size = s; p = store; }
// // ...
// public:
// buffer(int s) { p = new char[size = s]; }
// // ...
// };
public void test13_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class T {
// public:
// T();
// // ...
// };
// class C : T {
// public:
// C(int);
// // ...
// };
// T a = 1; // illformed: T(C(1)) not tried
public void test13_3_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f1(int);
// int f2(float);
// typedef int (*fp1)(int);
// typedef int (*fp2)(float);
// struct A {
// operator fp1() { return f1; }
// operator fp2() { return f2; }
// } a;
// int i = a(1); // Calls f1 via pointer returned from
// // conversion function
public void test13_3_1_1_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class String {
// public:
// String (const String&);
// String (char*);
// operator char* ();
// };
// String operator + (const String&, const String&);
// void f(void)
// {
// char* p= "one" + "two"; // illformed because neither
// // operand has user defined type
// int I = 1 + 1; // Always evaluates to 2 even if
// // user defined types exist which
// // would perform the operation.
// }
public void test13_3_1_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// operator int();
// };
// A operator+(const A&, const A&);
// void m() {
// A a, b;
// a + b; // operator+(a,b) chosen over int(a) + int(b)
// }
public void test13_3_1_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// A();
// operator int();
// operator double();
// } a;
// int i = a; // a.operator int() followed by no conversion
// // is better than a.operator double() followed by
// // a conversion to int
// float x = a; // ambiguous: both possibilities require conversions,
// // and neither is better than the other
public void test13_3_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void Fcn(const int*, short);
// void Fcn(int*, int);
// int i;
// short s = 0;
// void f() {
// Fcn(&i, s); // is ambiguous because
// // &i -> int* is better than &i -> const int*
// // but s -> short is also better than s -> int
// Fcn(&i, 1L); // calls Fcn(int*, int), because
// // &i -> int* is better than &i -> const int*
// // and 1L -> short and 1L -> int are indistinguishable
// Fcn(&i,'c'); //callsFcn(int*, int), because
// // &i -> int* is better than &i -> const int*
// // and c -> int is better than c -> short
// }
public void test13_3_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class B;
// class A { A (B&); };
// class B { operator A (); };
// class C { C (B&); };
// void f(A) { }
// void f(C) { }
// B b;
// f(b); //ambiguous because b -> C via constructor and
// // b -> A via constructor or conversion function.
public void test13_3_3_1_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A {};
// struct B : public A {} b;
// int f(A&);
// int f(B&);
// int i = f(b); // Calls f(B&), an exact match, rather than
// // f(A&), a conversion
public void test13_3_3_1_4s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(const int *);
// int f(int *);
// int i;
// int j = f(&i); // Calls f(int *)
public void test13_3_3_2s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(const int &);
// int f(int &);
// int g(const int &);
// int g(int);
// int i;
// int j = f(i); // Calls f(int &)
// int k = g(i); // ambiguous
// class X {
// public:
// void f() const;
// void f();
// };
// void g(const X& a, X b)
// {
// a.f(); //CallsX::f() const
// b.f(); //Calls X::f()
// }
public void test13_3_3_2s3b() throws Exception {
String[] problems= {"g"};
parse(getAboveComment(), ParserLanguage.CPP, problems);
}
// struct A {
// operator short();
// } a;
// int f(int);
// int f(float);
// int i = f(a); // Calls f(int), because short -> int is
// // better than short -> float.
public void test13_3_3_2s3c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {};
// struct B : public A {};
// struct C : public B {};
// C *pc;
// int f(A *);
// int f(B *);
// int i = f(pc); // Calls f(B *)
public void test13_3_3_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// int f(int);
// static int f(long);
// };
// int (X::*p1)(int) = &X::f; // OK
// int (*p2)(int) = &X::f; // error: mismatch
// int (*p3)(long) = &X::f; // OK
// int (X::*p4)(long) = &X::f; // error: mismatch
// int (*p6)(long) = &(X::f); // OK
public void test13_4s5b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class complex {
// public:
// complex operator+(complex a) {}
// };
// int n;
// int foo(complex &a, complex &b) {
// complex z = a.operator+(b); // complex z = a+b;
// void* p = operator new(sizeof(int)*n);
// }
public void test13_5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual int operator= (int);
// virtual B& operator= (const B&);
// };
// struct D : B {
// virtual int operator= (int);
// virtual D& operator= (const B&);
// };
// D dobj1;
// D dobj2;
// B* bptr = &dobj1;
// void f() {
// bptr->operator=(99); // calls D::operator=(int)
// *bptr = 99; // ditto
// bptr->operator=(dobj2); // calls D::operator=(const B&)
// *bptr = dobj2; // ditto
// dobj1 = dobj2; // calls implicitlydeclared
// // D::operator=(const D&)
// }
public void test13_5_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// X& operator++(); // prefix ++a
// X operator++(int); // postfix a++
// };
// class Y { };
// Y& operator++(Y&); // prefix ++b
// Y operator++(Y&, int); // postfix b++
// void f(X a, Y b) {
// ++a; // a.operator++();
// a++; // a.operator++(0);
// ++b; // operator++(b);
// b++; // operator++(b, 0);
// a.operator++(); // explicit call: like ++a;
// a.operator++(0); // explicit call: like a++;
// operator++(b); //explicit call: like ++b;
// operator++(b, 0); // explicit call: like b++;
// }
public void test13_5_7s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<const X& x, int i> void f()
// {
// i++; //error: change of template parameter
// value
// &x; //OK
// &i; //error: address of nonreference template parameter
// int& ri = i; // error: nonconst reference bound to temporary
// const int& cri = i; // OK: const reference bound to temporary
// }
public void test14_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<double d> class X; // error
// template<double* pd> class Y; // OK
// template<double& rd> class Z; // OK
public void test14_1s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int *a> struct R { };
// template<int b[5]> struct S { };
// int *p;
// R<p> w; // OK
// S<p> x; // OK due to parameter adjustment
// int v[5];
// R<v> y; // OK due to implicit argument conversion
// S<v> z; // OK due to both adjustment and conversion
public void test14_1s8() throws Exception { // TODO raised bug 90668
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1, class T2 = int> class A;
// template<class T1 = int, class T2> class A;
public void test14_1s10a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1 = int, class T2 = int> class A;
public void test14_1s10b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1 = int, class T2> class B; // error
public void test14_1s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T = int> class X;
// template<class T = int> class X { }; // error
public void test14_1s12() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T, T* p, class U = T> class X { };
// template<class T> void f(T* p = new T);
public void test14_1s13() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int i = (3 > 4) > // OK
// class Y { };
public void test14_1s15() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int i> class X { };
// X<(1>2)> x2; // OK
// template<class T> class Y { };
// Y< X<1> > x3; // OK
// // with C++0x this is no longer valid:
// // Y<X<6>> 1> > x4; // OK: Y< X< (6>>1) > >
public void test14_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// public:
// template<size_t> X* alloc();
// template<size_t> static X* adjust();
// };
// template<class T> void f(T* p)
// {
// T* p1 = p>
// alloc<200>(); // illformed: < means less than
// T* p2 = p->template alloc<200>();
// // OK: < starts template argument list
// T::adjust<100>();
// // illformed: < means less than
// T::template adjust<100>();
// // OK: < starts explicit qualification
// }
public void test14_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<typename T> class complex {
// complex(T,T) {}
// };
// template<class T> class Array {
// T* v;
// int sz;
// public:
// explicit Array(int);
// T& operator[](int);
// T& elem(int i) { return v[i]; }
// // ...
// };
// Array<int> v1(20);
// typedef complex<double> dcomplex;
// Array<dcomplex> v2(30);
// Array<dcomplex> v3(40);
// void bar() {
// v1[3] = 7;
// v2[3] = v3.elem(4) = dcomplex(7,8);
// }
public void test14_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class X {
// static T t;
// };
// class Y {
// private:
// struct S { };
// X<S> x; // OK: S is accessible
// // X<Y::S> has a static member of type Y::S
// // OK: even though Y::S is private
// };
// X<Y::S> y; // error: S not accessible
public void test14_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// ~A();
// };
// void f(A<int>* p, A<int>* q) {
// p->A<int>::~A(); // OK: destructor call
// q->A<int>::~A<int>(); // OK: destructor call
// }
public void test14_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> class X { };
// void f()
// {
// struct S { };
// X<S> x3; // error: local type used as templateargument
// X<S*> x4; // error: pointer to local type used as templateargument
// }
public void test14_3_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// static T t;
// };
// typedef int function();
// A<function> a; // illformed: would declare A<function>::t
// // as a static member function
public void test14_3_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class A { // primary template
// int x;
// };
// template<class T> class A<T*> { // partial specialization
// long x;
// };
// template<template<class U> class V> class C {
// V<int> y;
// V<int*> z;
// };
// C<A> c; // V<int> within C<A> uses the primary template,
// // so c.y.x has type int
// // V<int*> within C<A> uses the partial specialization,
// // so c.z.x has type long
public void test14_3_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class E, int size> class buffer { };
// buffer<char,2*512> x;
// buffer<char,1024> y;
public void test14_2s1a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T, void(*err_fct)()> class list { };
// list<int,&error_handler1> x1;
// list<int,&error_handler2> x2;
// list<int,&error_handler2> x3;
// list<char,&error_handler2> x4;
public void test14_4s1b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> class Array {
// T* v;
// int sz;
// public:
// explicit Array(int);
// T& operator[](int);
// T& elem(int i) { return v[i]; }
// // ...
// };
public void test14_5_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1, class T2> struct A {
// void f1();
// void f2();
// };
// template<class T2, class T1> void A<T2,T1>::f1() { } // OK
public void test14_5_1s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void error(const char*);
// template<class T> class Array {
// T* v;
// int sz;
// public:
// explicit Array(int);
// T& operator[](int);
// T& elem(int i) { return v[i]; }
// // ...
// };
// template<class T> T& Array<T>::operator[](int i)
// {
// if (i<0 || sz<=i) error("Array: range error");
// return v[i];
// }
public void test14_5_1_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void test() {
// Array<int> v1(20);
// Array<dcomplex> v2(30);
// v1[3] = 7; // Array<int>::operator[]()
// v2[3] = dcomplex(7,8); // Array<dcomplex>::operator[]()
// }
public void test14_5_1_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> struct A {
// class B;
// };
// A<int>::B* b1; // OK: requires A to be defined but not A::B
// template<class T> class A<T>::B { };
// A<int>::B b2; // OK: requires A::B to be defined
public void test14_5_1_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class string {
// public:
// template<class T2> int compare(const T2&);
// template<class T2> string(const string<T2>& s) { }
// // ...
// };
// template<class T> template<class T2> int string<T>::compare(const T2& s)
// {
// // ...
// }
public void test14_5_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class B {
// virtual void f(int);
// };
// class D : public B {
// template <class T> void f(T); // does not override B::f(int)
// void f(int i) { f<>(i); } // overriding function that calls
// // the template instantiation
// };
public void test14_5_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// template <class T> operator T*();
// };
// template <class T> A::operator T*(){ return 0; }
// template <> A::operator char*(){ return 0; } // specialization
// template A::operator void*(); // explicit instantiation
// int main()
// {
// A a;
// int* ip;
// ip = a.operator int*(); // explicit call to template operator
// // A::operator int*()
// }
public void test14_5_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class X {
// static T s;
// };
// template<class T> T X<T>::s = 0;
public void test14_5_1_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class task;
// template<class T> task<T>* preempt(task<T>*);
// template<class T> class task {
// // ...
// friend void next_time();
// friend void process(task<T>*);
// friend task<T>* preempt<T>(task<T>*);
// template<class C> friend int func(C);
// friend class task<int>;
// template<class P> friend class frd;
// // ...
// };
public void test14_5_4s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// template <class T> void f(T);
// void g(int);
// namespace M {
// template <class T> void h(T);
// template <class T> void i(T);
// struct A {
// friend void f<>(int); // illformed- N::f
// friend void h<>(int); // OK - M::h
// friend void g(int); // OK - new decl of M::g
// template <class T> void i(T);
// friend void i<>(int); // illformed- A::i
// };
// }
// }
public void test14_5_4s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class A {
// template<class T> friend class B; // OK
// template<class T> friend void f(T){ } // OK
// };
public void test14_5_4s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X {
// template<class T> friend struct A;
// class Y { };
// };
// template<class T> struct A { X::Y ab; }; // OK
// template<class T> struct A<T*> { X::Y ab; }; // OK
public void test14_5_4s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// struct B { };
// void f();
// };
// class C {
// template<class T> friend struct A<T>::B;
// template<class T> friend void A<T>::f();
// };
public void test14_5_4s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// template<class T2> struct B {}; // #1
// template<class T2> struct B<T2*> {}; // #2
// };
// template<> template<class T2> struct A<short>::B {}; // #3
// A<char>::B<int*> abcip; // uses #2
// A<short>::B<int*> absip; // uses #3
// A<char>::B<int> abci; // uses #1
public void test14_5_5_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1, class T2, int I> class A { }; // #1
// template<class T, int I> class A<T, T*, I> { }; // #2
// template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #3
// template<class T> class A<int, T*, 5> { }; // #4
// template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #5
public void test14_5_5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <int I, int J> struct B {};
// template <int I> struct B<I, I> {}; // OK
public void test14_5_5s9b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1, class T2, int I> class A { }; // #1
// template<class T, int I> class A<T, T*, I> { }; // #2
// template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #3
// template<class T> class A<int, T*, 5> { }; // #4
// template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #5
// A<int, int, 1> a1; // uses #1
// A<int, int*, 1> a2; // uses #2, T is int, I is 1
// A<int, char*, 5> a3; // uses #4, T is char
// A<int, char*, 1> a4; // uses #5, T1 is int, T2 is char, I is 1
public void test14_5_5_1s2a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1, class T2, int I> class A { }; // #1
// template<class T, int I> class A<T, T*, I> { }; // #2
// template<class T1, class T2, int I> class A<T1*, T2, I> { }; // #3
// template<class T> class A<int, T*, 5> { }; // #4
// template<class T1, class T2, int I> class A<T1, T2*, I> { }; // #5
// A<int*, int*, 2> a5; // ambiguous: matches #3 and #5 : expect problem
public void test14_5_5_1s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 1);
}
// template<int I, int J, class T> class X { };
// template<int I, int J> class X<I, J, int> { }; // #1
// template<int I> class X<I, I, int> { }; // #2
// template<int I, int J> void f(X<I, J, int>); // #A
// template<int I> void f(X<I, I, int>); // #B
public void test14_5_5_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // primary template
// template<class T, int I> struct A {
// void f();
// };
// template<class T, int I> void A<T,I>::f() { }
// // class template partial specialization
// template<class T> struct A<T,2> {
// void f();
// void g();
// void h();
// };
// // member of class template partial specialization
// template<class T> void A<T,2>::g() { }
// // explicit specialization
// template<> void A<char,2>::h() { }
// int main()
// {
// A<char,0> a0;
// A<char,2> a2;
// a0.f(); //OK, uses definition of primary template's member
// a2.g(); //OK, uses definition of
// // partial specialization's member
// a2.h(); //OK, uses definition of
// // explicit specialization's member
// a2.f(); //illformed, no definition of f for A<T,2>
// // the primary template is not used here
// }
public void test14_5_5_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> class Array { };
// template<class T> void sort(Array<T>&);
public void test14_5_6s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // file1.c
// template<class T>
// void f(T*);
// void g(int* p) {
// f(p); // call
// // f<int>(int*)
// }
public void test14_5_6_1s1a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // file2.c
// template<class T>
// void f(T);
// void h(int* p) {
// f(p); // call
// // f<int*>(int*)
// }
public void test14_5_6_1s1b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // Guaranteed to be the same
// template <int T> class A;
// template <int I> void f/*1*/(A<I>, A<I+10>);
// template <int I> void f/*2*/(A<I>, A<I+10>);
// // Guaranteed to be different
// template <int I> void f/*3*/(A<I>, A<I+11>);
public void test14_5_6_1s8a() throws Exception {
final String content= getAboveComment();
IASTTranslationUnit tu= parse(content, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
ICPPFunctionTemplate f1= bh.assertNonProblem("f/*1*/", 1);
ICPPFunctionTemplate f2= bh.assertNonProblem("f/*2*/", 1);
ICPPFunctionTemplate f3= bh.assertNonProblem("f/*3*/", 1);
assertSame(f1, f2);
assertNotSame(f1, f3);
}
// // Illformed, no diagnostic required
// template <int I> void f(A<I>, A<I+10>);
// template <int I> void f(A<I>, A<I+1+2+3+4>);
public void test14_5_6_1s8b() throws Exception {
//test is only for syntax, semantics are not checked here.
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A { };
// template<class T> struct B {
// template<class R> int operator*(R&); // #1
// };
// template<class T, class R> int operator*(T&, R&); // #2
// // The declaration of B::operator* is transformed into the equivalent of
// // template<class R> int operator*(B<A>&, R&); // #1a
// int main() {
// A a;
// B<A> b;
// b * a; // calls #1a
// }
public void test14_5_6_2s3() throws Exception {
String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
IBinding op1= bh.assertNonProblem("operator*(R&)", -4);
IASTImplicitName name= bh.assertImplicitName("* a", 1, ICPPFunction.class);
ICPPTemplateInstance inst= (ICPPTemplateInstance) name.resolveBinding();
ICPPSpecialization templateSpecialization = (ICPPSpecialization) inst.getTemplateDefinition();
assertSame(op1, templateSpecialization.getSpecializedBinding());
}
// template<class T> struct A { A(); };
// template<class T> void f(T);
// template<class T> void f(T*);
// template<class T> void f(const T*);
// template<class T> void g(T);
// template<class T> void g(T&);
// template<class T> void h(const T&);
// template<class T> void h(A<T>&);
// void m() {
// const int *p;
// f(p); // f(const T*) is more specialized than f(T) or f(T*)
// float x;
// g(x); //Ambiguous: g(T) or g(T&)
// A<int> z;
// h(z); //overload resolution selects h(A<T>&)
// const A<int> z2;
// h(z2); // h(const T&) is called because h(A<T>&) is not callable
// }
public void test14_5_6_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> void f(T); // #1
// template<class T> void f(T*, int=1); // #2
// template<class T> void g(T); // #3
// template<class T> void g(T*, ...); // #4
// int main() {
// int* ip;
// f(ip); //calls #2
// g(ip); //calls #4
// }
public void test14_5_6_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // no B declared here
// class X;
// template<class T> class Y {
// class Z; // forward declaration of member class
// void f() {
// X* a1; // declare pointer to X
// T* a2; // declare pointer to T
// Y* a3; // declare pointer to Y<T>
// Z* a4; // declare pointer to Z
// typedef typename T::A TA;
// TA* a5; // declare pointer to T's A
// typename T::A* a6; // declare pointer to T's A
// T::A* a7; // T::A is not a type name:
// // multiply T::A by a7; illformed,
// // no visible declaration of a7
// B* a8; // B is not a type name:
// // multiply B by a8; illformed,
// // no visible declarations of B and a8
// }
// };
public void test14_6s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A {
// struct X { };
// int X;
// };
// template<class T> void f(T t) {
// typename T::X x; // illformed: finds the data member X
// // not the member type X
// }
public void test14_6s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// typedef int B;
// A::B b; // illformed: typename required before A::B
// void f(A<T>::B); // illformed: typename required before A<T>::B
// typename A::B g(); // OK
// };
public void test14_6s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int j;
// template<class T> class X {
// // ...
// void f(T t, int i, char* p)
// {
// t = i; // diagnosed if X::f is instantiated
// // and the assignment to t is an error
// p = i; // may be diagnosed even if X::f is
// // not instantiated
// p = j; // may be diagnosed even if X::f is
// // not instantiated
// }
// void g(T t) {
// // +; //may be diagnosed even if X::g is
// // not instantiated
// }
// };
public void test14_6s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// //#include <iostream>
// using namespace std;
// template<class T> class Set {
// T* p;
// int cnt;
// public:
// Set();
// Set<T>(const Set<T>&);
// void printall()
// {
// for (int i = 0; i<cnt; i++)
// cout << p[i] << '\
// ';
// }
// // ...
// };
public void test14_6s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void f(char);
// template<class T> void g(T t)
// {
// f(1); // f(char)
// f(T(1)); //dependent
// f(t); //dependent
// dd++; //not dependent
// // error: declaration for dd not found
// }
// void f(int);
// double dd;
// void h()
// {
// g(2); //will cause one call of f(char) followed
// // by two calls of f(int)
// g('a'); //will cause three calls of f(char)
// }
public void test14_6s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T, T* p, class U = T> class X { };
// template<class T> void f(T* p = new T);
public void test14_6_1s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class X {
// X* p; // meaning X<T>
// X<T>* p2;
// X<int>* p3;
// };
public void test14_6_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class Y;
// template<> class Y<int> {
// Y* p; // meaning Y<int>
// Y<char>* q; // meaning Y<char>
// };
public void test14_6_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<typename T> class Array {};
// template<class T> class X : public Array<T> { };
// template<class T> class Y : public T { };
public void test14_6_1s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T, int i> class Y {
// int T; // error: templateparameter redeclared
// void f() {
// char T; // error: templateparameter redeclared
// }
// };
// template<class X> class X; // error: templateparameter redeclared
public void test14_6_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// struct B { };
// void f();
// };
// template<class B> void A<B>::f() {
// B b; // A's B, not the template parameter
// }
public void test14_6_1s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// int C;
// template<class T> class B {
// void f(T);
// };
// }
// template<class C> void N::B<C>::f(C) {
// C b; // C is the template parameter, not N::C
// }
public void test14_6_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// struct B { };
// int a;
// int Y;
// };
// template<class B, class a> struct X : A {
// B b; // A's B
// a b; // error: A's a isn't a type name
// };
public void test14_6_1s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template <typename T> class B {};
// template<class T> struct X : B<T> {
// typename T::A* pa;
// void f(B<T>* pb) {
// static int i = B<T>::i;
// pb->j++;
// }
// };
public void test14_6_2s2() throws Exception {
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPUnknownBinding unknown= bh.assertNonProblem("B<T>", 4);
unknown= bh.assertNonProblem("T::A", 4);
unknown= bh.assertNonProblem("B<T>::i", 7);
unknown= bh.assertNonProblem("j", 1);
}
// typedef double A;
// template<class T> class B {
// typedef int A;
// };
// template<class T> struct X : B<T> {
// A a; // a has type double
// };
public void test14_6_2s3() throws Exception {
final String content= getAboveComment();
IASTTranslationUnit tu= parse(content, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
IVariable v= bh.assertNonProblem("a;", 1);
IType t= v.getType();
assertInstance(t, ITypedef.class);
t= ((ITypedef) t).getType();
assertInstance(t, IBasicType.class);
assertEquals(IBasicType.t_double, ((IBasicType) t).getType());
}
// struct A {
// struct B { };
// int a;
// int Y;
// };
// int a;
// template<class T> struct Y : T {
// struct B { };
// B b; // The B defined in Y
// void f(int i) { a = i; } // ::a
// Y* p; // Y<T>
// };
// Y<A> ya;
public void test14_6_2s4() throws Exception {
final String content= getAboveComment();
parse(content, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
IBinding b= bh.assertNonProblem("b;", 1);
assertEquals("Y", b.getOwner().getName());
b= bh.assertNonProblem("a = i", 1);
assertNull(b.getOwner());
}
// void g(double);
// void h();
// template<class T> class Z {
// public:
// void f() {
// g(1); //calls g(double)
// h++; //illformed:
// // cannot increment function;
// // this could be diagnosed either here or
// // at the point of instantiation
// }
// };
// void g(int); // not in scope at the point of the template
// // definition, not considered for the call g(1)
public void test14_6_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<typename T> class number {
// number(int);
// //...
// friend number gcd(number& x, number& y) { }
// //...
// };
// void g()
// {
// number<double> a(3), b(4);
// //...
// a = gcd(a,b); // finds gcd because number<double> is an
// // associated class, making gcd visible
// // in its namespace (global scope)
// b = gcd(3,4); // illformed; gcd is not visible
// }
public void test14_6_5s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> class X {
// static T s;
// // ...
// };
// template<class T> T X<T>::s = 0;
// X<int> aa;
// X<char*> bb;
public void test14_7s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class Z {
// public:
// void f();
// void g();
// };
// void h()
// {
// Z<int> a; // instantiation of class Z<int> required
// Z<char>* p; // instantiation of class Z<char> not
// // required
// Z<double>* q; // instantiation of class Z<double>
// // not required
// a.f(); //instantiation of Z<int>::f() required
// p->g(); //instantiation of class Z<char> required, and
// // instantiation of Z<char>::g() required
// }
public void test14_7_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class B { };
// template<class T> class D : public B<T> { };
// void f(void*);
// void f(B<int>*);
// void g(D<int>* p, D<char>* pp, D<double> ppp)
// {
// f(p); //instantiation of D<int> required: call f(B<int>*)
// B<char>* q = pp; // instantiation of D<char> required:
// // convert D<char>* to B<char>*
// delete ppp; // instantiation of D<double> required
// }
public void test14_7_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class X;
// X<char> ch; // error: definition of X required
public void test14_7_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T = int> struct A {
// static int x;
// };
// template<class U> void g(U) { }
// template<> struct A<double> { }; // specialize for T == double
// template<> struct A<> { }; // specialize for T == int
// template<> void g(char) { } // specialize for U == char
// // U is deduced from the parameter type
// template<> void g<int>(int) { } // specialize for U == int
// template<> int A<char>::x = 0; // specialize for T == char
// template<class T = int> struct B {
// static int x;
// };
// template<> int B<>::x = 1; // specialize for T == int
public void test14_7s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> struct S {
// operator int();
// };
// void f(int);
// void f(S<int>&);
// void f(S<float>);
// void g(S<int>& sr) {
// f(sr); //instantiation of S<int> allowed but not required
// // instantiation of S<float> allowed but not required
// };
public void test14_7_1s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// template<class T> class List {
// public:
// T* get();
// // ...
// };
// }
// template<class K, class V> class Map {
// N::List<V> lt;
// V get(K);
// // ...
// };
// void g(Map<char*,int>& m)
// {
// int i = m.get("Nicholas");
// // ...
// }
public void test14_7_1s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void f(T x, T y = ydef(T()), T z = zdef(T()));
// class A { };
// A zdef(A);
// void g(A a, A b, A c) {
// f(a, b, c); // no default argument instantiation
// f(a, b); // default argument z = zdef(T()) instantiated
// f(a); //illformed; ydef is not declared
// }
public void test14_7_1s12() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> class X {
// X<T>* p; // OK
// X<T*> a; // implicit generation of X<T> requires
// // the implicit instantiation of X<T*> which requires
// // the implicit instantiation of X<T**> which ...
// };
public void test14_7_1s14() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class Array { void mf(); };
// template class Array<char>;
// template void Array<int>::mf();
// template<class T> void sort(Array<T>& v) { }
// template void sort(Array<char>&); // argument is deduced here
// namespace N {
// template<class T> void f(T&) { }
// }
// template void N::f<int>(int&);
public void test14_7_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// template<class T> class Y { void mf() { } };
// }
// template class Y<int>; // error: class template Y not visible
// // in the global namespace
// using N::Y;
// template class Y<int>; // OK: explicit instantiation in namespace N
// template class N::Y<char*>; // OK: explicit instantiation in namespace N
// template void N::Y<double>::mf(); // OK: explicit instantiation
// // in namespace N
public void test14_7_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> class Array { };
// template<class T> void sort(Array<T>& v);
// // instantiate sort(Array<int>&) - templateargument deduced
// template void sort<>(Array<int>&);
public void test14_7_2s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// char* p = 0;
// template<class T> T g(T = &p);
// template int g<int>(int); // OK even though &p isn't an int.
public void test14_7_2s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class stream;
// template<> class stream<char> { };
// template<class T> class Array { };
// template<class T> void sort(Array<T>& v) { }
// template<> void sort<char*>(Array<char*>&) ;
public void test14_7_3s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<> class X<int> { }; // error: X not a template
// template<class T> class X;
// template<> class X<char*> { }; // OK: X is a template
public void test14_7_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> struct A {
// void f(T) { }
// };
// template<> struct A<int> {
// void f(int);
// };
// void h()
// {
// A<int> a;
// a.f(16); // A<int>::f must be defined somewhere
// }
// // explicit specialization syntax not used for a member of
// // explicitly specialized class template specialization
// void A<int>::f(int) { }
public void test14_7_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class Array { };
// template<class T> void sort(Array<T>& v) { }
// void f(Array<String>& v)
// {
// sort(v); //use primary template
// // sort(Array<T>&), T is String
// }
// template<> void sort<String>(Array<String>& v); // error: specialization
// // after use of primary template
// template<> void sort<>(Array<char*>& v); // OK: sort<char*> not yet used
public void test14_7_3s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// namespace N {
// template<class T> class X { };
// template<class T> class Y { };
// template<> class X<int> { }; // OK: specialization
// // in same namespace
// template<> class Y<double>; // forward declare intent to
// // specialize for double
// }
// template<> class N::Y<double> { }; // OK: specialization
// // in same namespace
public void test14_7_3s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class Array { };
// template<class T> void sort(Array<T>& v);
// // explicit specialization for sort(Array<int>&)
// // with deduces templateargument of type int
// template<> void sort(Array<int>&);
public void test14_7_3s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0 );
}
// template<class T1> class A {
// template<class T2> class B {
// void mf();
// };
// };
// template<> template<> class A<int>::B<double> { };
// template<> template<> void A<char>::B<char>::mf() { };
public void test14_7_3s17() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class X; // X is a class template
// template<> class X<int>;
// X<int>* p; // OK: pointer to declared class X<int>
// X<int> x; // error: object of incomplete class X<int>
public void test14_7_3s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> void f(T);
// template <class T> void f(T*);
// template <> void f(int*); // Ambiguous
// template <> void f<int>(int*); // OK
// template <> void f(int); // OK
public void test14_7_3s12() throws Exception {
// gcc does not report the explicit instantiation as ambiguous, so we accept it as well.
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void f(T) { }
// template<class T> inline T g(T) { }
// template<> inline void f<>(int) { } // OK: inline
// template<> int g<>(int) { } // OK: not inline
public void test14_7_3s14() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct A {
// void f(T);
// template<class X> void g(T,X);
// void h(T) { }
// };
// // specialization
// template<> void A<int>::f(int);
// // out of class member template definition
// template<class T> template<class X> void A<T>::g(T,X) { }
// // member template partial specialization
// template<> template<class X> void A<int>::g(int,X);
// // member template specialization
// template<> template<>
// void A<int>::g(int,char); // X deduced as char
// template<> template<>
// void A<int>::g<char>(int,char); // X specified as char
// // member specialization even if defined in class definition
// template<> void A<int>::h(int) { }
public void test14_7_3s16() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T1> class A {
// template<class T2> class B {
// template<class T3> void mf1(T3);
// void mf2();
// };
// };
// template<> template<class X>
// class A<int>::B { };
// template<> template<> template<class T>
// void A<int>::B<double>::mf1(T t) { };
// template<class Y> template<>
// void A<Y>::B<double>::mf2() { }; // illformed; B<double> is specialized but
// // its enclosing class template A is not
public void test14_7_3s18() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> void f(T* p)
// {
// static T s;
// // ...
// };
// void g(int a, char* b)
// {
// f(&a); //call f<int>(int*)
// f(&b); //call f<char*>(char**)
// }
public void test14_8s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void sort(Array<T>& v);
// void f(Array<dcomplex>& cv, Array<int>& ci)
// {
// sort<dcomplex>(cv); // sort(Array<dcomplex>&)
// sort<int>(ci); // sort(Array<int>&)
// }
// template<class U, class V> U convert(V v);
// void g(double d)
// {
// int i = convert<int,double>(d); // int convert(double)
// char c = convert<char,double>(d); // char convert(double)
// }
public void test14_8_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class X, class Y> X f(Y);
// void g()
// {
// int i = f<int>(5.6); // Y is deduced to be double
// int j = f(5.6); // illformed: X cannot be deduced
// }
public void test14_8_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class X, class Y, class Z> X f(Y,Z);
// void g()
// {
// f<int,char*,double>("aa",3.0);
// f<int,char*>("aa",3.0); // Z is deduced to be double
// f<int>("aa",3.0); // Y is deduced to be char*, and
// // Z is deduced to be double
// f("aa",3.0); //error: X cannot be deduced
// }
public void test14_8_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> void f(T);
// class Complex {
// // ...
// Complex(double);
// };
// void g()
// {
// f<Complex>(1); // OK, means f<Complex>(Complex(1))
// }
public void test14_8_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// struct B { };
// template<int X> void f();
// }
// namespace C {
// template<class T> void f(T t);
// }
// void g(A::B b) {
// f<3>(b); //illformed: not a function call
// A::f<3>(b); //wellformed
// C::f<3>(b); //illformed; argument dependent lookup
// // only applies to unqualified names
// using C::f;
// f<3>(b); //wellformed because C::f is visible; then
// // A::f is found by argument dependent lookup
// }
public void test14_8_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// void f(Array<dcomplex>& cv, Array<int>& ci)
// {
// sort(cv); //call sort(Array<dcomplex>&)
// sort(ci); //call sort(Array<int>&)
// }
// void g(double d)
// {
// int i = convert<int>(d); // call convert<int,double>(double)
// int c = convert<char>(d); // call convert<char,double>(double)
// }
public void test14_8_2s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template <class T> void f(T t);
// template <class X> void g(const X x);
// template <class Z> void h(Z, Z*);
// int main()
// {
// // #1: function type is f(int), t is nonconst
// f<int>(1);
// // #2: function type is f(int), t is const
// f<const int>(1);
// // #3: function type is g(int), x is const
// g<int>(1);
// // #4: function type is g(int), x is const
// g<const int>(1);
// // #5: function type is h(int, const int*)
// h<const int>(1,0);
// }
public void test14_8_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T, class U = double>
// void f(T t = 0, U u = 0);
// void g() {
// f(1, 'c'); // f<int,char>(1,'c')
// f(1); // f<int,double>(1,0)
// f(); // error: T cannot be deduced
// f<int>(); // f<int,double>(0,0)
// f<int,char>(); // f<int,char>(0,0)
// }
public void test14_8_2s5() throws Exception {
final String content= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(1, 'c')", 1);
assertEquals("<int,char>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f(1)", 1);
assertEquals("<int,double>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f()", 1);
inst= bh.assertNonProblem("f<int>()", -2);
assertEquals("<int,double>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f<int,char>()", -2);
assertEquals("<int,char>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// struct X { };
// struct Y {
// Y(X){}
// };
// template <class T> auto f(T t1, T t2) -> decltype(t1 + t2); // #1
// X f(Y, Y); // #2
// X x1, x2;
// X x3 = f(x1, x2); // deduction fails on #1 (cannot add X+X), calls #2
public void test14_8_2s8a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template <class T> int f(T[5]);
// int I = f<int>(0);
// int j = f<void>(0); // invalid array
public void _test14_8_2s8b() throws Exception {
final String content= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
bh.assertNonProblem("f<int>(0)", -3);
bh.assertProblem("f<void>(0)", -3);
}
// template <class T> int f(typename T::B*);
// int i = f<int>(0);
public void test14_8_2s8c() throws Exception {
final String content= getAboveComment();
IASTTranslationUnit tu= parse(content, ParserLanguage.CPP, true, 2);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
bh.assertProblem("f<", 1);
bh.assertProblem("f<int>", 6);
}
// template <int I> struct X { };
// template <template <class T> class> struct Z { };
// template <class T> void f(typename T::Y*){}
// template <class T> void g(X<T::N>*){}
// template <class T> void h(Z<T::template TT>*){}
// struct A {};
// struct B { int Y; };
// struct C {
// typedef int N;
// };
// struct D {
// typedef int TT;
// };
// int main() {
// // Deduction fails in each of these cases:
// f<A>(0); // A does not contain a member Y
// f<B>(0); // The Y member of B is not a type
// g<C>(0); // The N member of C is not a non-type
// h<D>(0); // The TT member of D is not a template
// }
public void test14_8_2s8d() throws Exception {
final String content= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
bh.assertProblem("f<A>", 0);
bh.assertProblem("f<B>", 0);
bh.assertProblem("g<C>", 0);
bh.assertProblem("h<D>", 0);
}
// template <class T> int f(int T::*);
// int i = f<int>(0);
public void test14_8_2s8e() throws Exception {
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, true, 2);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
bh.assertProblem("f<int>", 0);
}
// template <class T, T> struct S {};
// template <class T> int f(S<T, T()>*);
// struct X {};
// int i0 = f<X>(0);
public void test14_8_2s8f() throws Exception {
final String code = getAboveComment();
parse(code, ParserLanguage.CPP, true, 2);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
bh.assertProblem("f<X>", 0);
}
// template <class T, T*> int f(int);
// int i2 = f<int,1>(0); // can't conv 1 to int*
public void test14_8_2s8g() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 1);
}
// template <int> int f(int);
// template <signed char> int f(int);
// int i1 = f<1>(0); // ambiguous
// int i2 = f<1000>(0); // ambiguous
public void test14_8_2s9() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 2);
}
// namespace std {
// template<typename T> class initializer_list;
// }
// template<class T> void f(std::initializer_list<T>);
// template<class T> void g(T);
// void test() {
// f({1,2,3}); // T deduced to int
// f({1,"asdf"}); // error: T deduced to both int and const char*
// g({1,2,3}); // error: no argument deduced for T
// }
public void test14_8_2_1s1a() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f({1,2,3})", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f({1,\"asdf\"})", 1);
bh.assertProblem("g({1,2,3})", 1);
}
// template<class ... Types> void f(Types& ...);
// template<class T1, class ... Types> void g(T1, Types ...);
// void h(int x, float& y) {
// const int z = x;
// f(x, y, z); // Types is deduced to int, float, const int
// g(x, y, z); // T1 is deduced to int; Types is deduced to float, int
// }
public void test14_8_2_1s1b() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(x, y, z)", 1);
assertEquals("<int,float,const int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("g(x, y, z)", 1);
assertEquals("<int,float,int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template <class T> int f(T&&);
// template <class T> int g(const T&&);
// int i;
// int n1 = f(i); // calls f<int&>(int&)
// int n2 = f(0); // calls f<int>(int&&)
// int n3 = g(i); // error: would call g<int>(const int&&), which
// // would bind an rvalue reference to an lvalue
public void test14_8_2_1s3() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(i)", 1);
assertEquals("<int &>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f(0)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("g(i)", 1);
}
// // Only one function of an overload set matches the call so the function
// // parameter is a deduced context.
// template <class T> int f(T (*p)(T));
// int g(int);
// int g(char);
// int i = f(g); // calls f(int (*)(int))
public void test14_8_2_1s7() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(g)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// // Ambiguous deduction causes the second function parameter to be a
// // non-deduced context.
// template <class T> int f(T, T (*p)(T));
// int g(int);
// char g(char);
// int i = f(1, g); // calls f(int, int (*)(int))
public void test14_8_2_1s8() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(1, g)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// // The overload set contains a template, causing the second function
// // parameter to be a non-deduced context.
// template <class T> int f(T, T (*p)(T));
// char g(char);
// template <class T> T g(T);
// int i = f(1, g); // calls f(int, int (*)(int))
public void test14_8_2_1s9() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(1, g)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// struct A {
// template <class T> operator T***();
// };
// A a;
// void test(const int * const * const * p1) {
// test(a); // T is deduced as int, not const int
// }
public void test14_8_2_3s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> T f(int); // #1
// template <class T, class U> T f(U); // #2
// void g() {
// f<int>(1); // calls #1
// }
public void test14_8_2_4s11() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<typename...> struct Tuple { };
// template<typename... Types> void g(Tuple<Types...>); // #1
// template<typename T1, typename... Types> void g(Tuple<T1, Types...>); // #2
// template<typename T1, typename... Types> void g(Tuple<T1, Types&...>); // #3
// void test() {
// g(Tuple<>()); // calls #1
// g(Tuple<int, float>()); // calls #2
// g(Tuple<int, float&>()); // calls #3
// g(Tuple<int>()); // calls #3
// }
public void test14_8_2_4s12() throws Exception {
final String code= getAboveComment();
parse(code, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPFunction g1= bh.assertNonProblem("g(Tuple<Types...>)", 1);
ICPPFunction g2= bh.assertNonProblem("g(Tuple<T1, Types...>)", 1);
ICPPFunction g3= bh.assertNonProblem("g(Tuple<T1, Types&...>)", 1);
ICPPTemplateInstance x= bh.assertNonProblem("g(Tuple<>())", 1);
assertSame(g1, x.getTemplateDefinition());
x= bh.assertNonProblem("g(Tuple<int, float>())", 1);
assertSame(g2, x.getTemplateDefinition());
x= bh.assertNonProblem("g(Tuple<int, float&>())", 1);
assertSame(g3, x.getTemplateDefinition());
x= bh.assertNonProblem("g(Tuple<int>())", 1);
assertSame(g3, x.getTemplateDefinition());
}
// template<class T> void g(T);
// void test() {
// g({1,2,3}); // error: no argument deduced for T
// }
public void test14_8_2_5s5() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
bh.assertProblem("g({1,2,3})", 1);
}
// template<class T> void f(T x, T y) { }
// struct A { };
// struct B : A { };
// int g(A a, B b)
// {
// f(a,b); //error: T could be A or B
// f(b,a); //error: T could be A or B
// f(a,a); //OK: T is A
// f(b,b); //OK: T is B
// }
public void test14_8_2_5s7a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template <class T, class U> void f( T (*)( T, U, U ) );
// int g1( int, float, float);
// char g2( int, float, float);
// int g3( int, char, float);
// void r()
// {
// f(g1); //OK: T is int and U is float
// f(g2); //error: T could be char or int
// f(g3); //error: U could be char or float
// }
public void test14_8_2_5s7b() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(g1)", 1);
assertEquals("<int,float>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f(g2)", 1);
bh.assertProblem("f(g3)", 1);
}
// template<class T> void f(const T*) {}
// int *p;
// void s()
// {
// f(p); // f(const int *)
// }
public void test14_8_2_5s7c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> struct B { };
// template <class T> struct D : public B<T> {};
// struct D2 : public B<int> {};
// template <class T> void f(B<T>&){}
// void t()
// {
// D<int> d;
// D2 d2;
// f(d); //calls f(B<int>&)
// f(d2); //calls f(B<int>&)
// }
public void test14_8_2_5s7d() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> void f(T&&);
// template <> void f(int&) { } // #1
// template <> void f(int&&) { } // #2
// void g(int i) {
// f(i); // calls f<int&>(int&), i.e., #1
// f(0); // calls f<int>(int&&), i.e., #2
// }
public void test14_8_2_5s10() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(i)", 1);
assertEquals("<int &>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f(0)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template<class T, T i> void f(double a[10][i]);
// int v[10][20];
// int foo() {
// f(v); //error: argument for templateparameter
// //T cannot be deduced
// }
public void test14_8_2_5s14() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
bh.assertProblem("f(v)", 1);
}
// template<int i> void f1(int a[10][i]);
// template<int i> void f2(int a[i][20]);
// template<int i> void f3(int (&a)[i][20]);
// void g()
// {
// int v[10][20];
// f1(v); //OK: i deduced to be 20
// f1<20>(v); //OK
// f2(v); //error: cannot deduce templateargument i
// f2<10>(v); //OK
// f3(v); //OK: i deduced to be 10
// }
public void test14_8_2_5s15() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f1(v)", 2);
assertEquals("<int20>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f1<20>(v)", -3);
assertEquals("<int20>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f2(v)", 2);
inst= bh.assertNonProblem("f2<10>(v)", -3);
assertEquals("<int10>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f3(v)", 2);
assertEquals("<int10>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template <int i> class A { };
// template <int i> void g(A<i+1>);
// template <int i> void f(A<i>, A<i+1>);
// void k() {
// A<1> a1;
// A<2> a2;
// g(a1); // error: deduction fails for expression i+1
// g<0>(a1); // OK
// f(a1, a2); // OK
// }
public void test14_8_2_5s16a() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
bh.assertProblem("g(a1)", 1);
inst= bh.assertNonProblem("g<0>(a1)", -4);
assertEquals("<int0>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("f(a1, a2)", 1);
assertEquals("<int1>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template<typename T> class A {
// public:
// typedef int X;
// X xm;
// };
// template<int I> class B {
// public:
// typedef int* Y;
// Y ym;
// };
// template<int i, typename T>
// T deduce(typename A<T>::X x, // T is not deduced here
// T t, // but T is deduced here
// typename B<i>::Y y); // i is not deduced here
// void test() {
// A<int> a;
// B<77> b;
// deduce<77> (a.xm, 62, b.ym);
// }
public void test14_8_2_5s16b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int i> class A {};
// template<short s> void f(A<s>);
// void k1() {
// A<1> a;
// f(a); // error: deduction fails for conversion from int to short
// f<1>(a); // OK
// }
// template<const short cs> class B { };
// template<short s> void g(B<s>);
// void k2() {
// B<1> b;
// g(b); // OK: cv-qualifiers are ignored on template parameter types
// }
public void test14_8_2_5s17() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
bh.assertProblem("f(a)", 1);
inst= bh.assertNonProblem("f<1>(a)", -3);
assertEquals("<short int1>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
inst= bh.assertNonProblem("g(b)", 1);
assertEquals("<short int1>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template<class T> void f(void(*)(T,int));
// template<class T> void foo(T,int);
// void g(int,int);
// void g(char,int);
// void h(int,int,int);
// void h(char,int);
// int m() {
// f(&g); // error: ambiguous
// f(&h); // OK: void h(char,int) is a unique match
// f(&foo); // error: type deduction fails because foo is a template
// }
public void test14_8_2_5s18() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
bh.assertProblem("f(&g)", 1);
inst= bh.assertNonProblem("f(&h)", 1);
assertEquals("<char>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f(&foo)", 1);
}
// template <class T> void f(T = 5, T = 7);
// void g() {
// f(1); // OK: call f<int>(1,7)
// f(); // error: cannot deduce T
// f<int>(); // OK: call f<int>(5,7)
// }
public void test14_8_2_5s19() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f(1)", 1);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
bh.assertProblem("f()", 1);
inst= bh.assertNonProblem("f<int>()", -2);
assertEquals("<int>", ASTTypeUtil.getArgumentListString(inst.getTemplateArguments(), true));
}
// template <template <class T> class X> struct A { };
// template <template <class T> class X> void f(A<X>) { }
// template<class T> struct B { };
// int foo() {
// A<B> ab;
// f(ab); //calls f(A<B>)
// }
public void test14_8_2_4s20() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class> struct X { };
// template<class R, class ... ArgTypes> struct X<R(int, ArgTypes ...)> { };
// template<class ... Types> struct Y { };
// template<class T, class ... Types> struct Y<T, Types& ...> { };
// template<class ... Types> int f(void (*)(Types ...));
// void g(int, float);
// X<int> x1; // uses primary template
// X<int(int, float, double)> x2; // uses partial specialization; ArgTypes contains float, double
// X<int(float, int)> x3; // uses primary template
// Y<> y1; // use primary template; Types is empty
// Y<int&, float&, double&> y2; // uses partial specialization; T is int&, Types contains float, double
// Y<int, float, double> y3; // uses primary template; Types contains int, float, double
// int fv = f(g); // OK; Types contains int, float
public void test14_8_2_4s21() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class ... Args> void f(Args ... args); // #1
// template<class T1, class ... Args> void f(T1 a1, Args ... args); // #2
// template<class T1, class T2> void f(T1 a1, T2 a2); // #3
// void test() {
// f(); // calls #1
// f(1, 2, 3); // calls #2
// f(1, 2); // calls #3; non-variadic template #3 is more
// // specialized than the variadic templates #1 and #2
// }
public void test14_8_2_5s22() throws Exception {
final String code= getAboveComment();
BindingAssertionHelper bh= new BindingAssertionHelper(code, true);
ICPPFunctionTemplate f1= bh.assertNonProblem("f(Args ... args)", 1);
ICPPFunctionTemplate f2= bh.assertNonProblem("f(T1 a1, Args ... args)", 1);
ICPPFunctionTemplate f3= bh.assertNonProblem("f(T1 a1, T2 a2)", 1);
ICPPTemplateInstance inst;
inst= bh.assertNonProblem("f()", 1);
assertSame(f1, inst.getTemplateDefinition());
inst= bh.assertNonProblem("f(1, 2, 3)", 1);
assertSame(f2, inst.getTemplateDefinition());
inst= bh.assertNonProblem("f(1, 2)", 1);
assertSame(f3, inst.getTemplateDefinition());
}
// template<class T> T max(T a, T b) { return a>b?a:b; }
// void f(int a, int b, char c, char d)
// {
// int m1 = max(a,b); // max(int a, int b)
// char m2 = max(c,d); // max(char a, char b)
// int m3 = max(a,c); // error: cannot generate max(int,char)
// }
public void test14_8_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> T max(T a, T b) { return a>b?a:b; }
// int max(int,int);
// void f(int a, int b, char c, char d)
// {
// int m1 = max(a,b); // max(int a, int b)
// char m2 = max(c,d); // max(char a, char b)
// int m3 = max(a,c); // resolved
// }
public void test14_8_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> struct B { };
// template<class T> struct D : public B<T> { };
// template<class T> void f(B<T>&);
// void g(B<int>& bi, D<int>& di)
// {
// f(bi); // f(bi)
// f(di); // f( (B<int>&)di )
// }
public void test14_8_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void f(T*,int); // #1
// template<class T> void f(T,char); // #2
// void h(int* pi, int i, char c)
// {
// f(pi,i); //#1: f<int>(pi,i)
// f(pi,c); //#2: f<int*>(pi,c)
// f(i,c); //#2: f<int>(i,c);
// f(i,i); //#2: f<int>(i,char(i))
// }
public void test14_8_3s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void f(T); // declaration
// void g() {
// f("Annemarie"); // call of f<const char*>
// }
public void test14_8_3s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// lab: try {
// int t1;
// try {
// int t2;
// if (1)
// goto lab;
// } catch(...) { // handler 2
// }
// } catch(...) { // handler 1
// }
// }
public void test15s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(int);
// class C {
// int i;
// double d;
// public:
// C(int, double);
// };
// C::C(int ii, double id)
// try
// : i(f(ii)), d(id)
// {
// // constructor function body
// }
// catch (...)
// {
// // handles exceptions thrown from the ctorinitializer
// // and from the constructor function body
// }
public void test15s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Overflow {
// // ...
// public:
// Overflow(char,double,double);
// };
// void f(double x)
// {
// // ...
// throw Overflow('+',x,3.45e107);
// }
// int foo() {
// try {
// // ...
// f(1.2);
// // ...
// }
// catch(Overflow& oo) {
// // handle exceptions of type Overflow here
// }
// }
public void test15_1s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int foo() {
// try {
// // ...
// }
// catch (...) { // catch all exceptions
// // respond (partially) to exception
// throw; //pass the exception to some
// // other handler
// }
// }
public void test15_1s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class Matherr { virtual void vf(); };
// class Overflow: public Matherr { };
// class Underflow: public Matherr { };
// class Zerodivide: public Matherr { };
// void f()
// {
// try {
// }
// catch (Overflow oo) {
// // ...
// }
// catch (Matherr mm) {
// // ...
// }
// }
public void test15_3s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// void f() throw(int); // OK
// void (*fp)() throw (int); // OK
// void g(void pfa() throw(int)); // OK
public void test15_4s1a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int (*pf)() throw(int); // illformed
public void test15_4s1b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <typename T>
// void f(T p);
//
// template <typename T>
// void g(T p) noexcept;
//
// template <typename T>
// void fg(T a) noexcept (noexcept(f(a)) && noexcept(g(a))) {
// f(a);
// g(a);
// }
public void test15_4s1c() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual void f() throw (int, double);
// virtual void g();
// };
// struct D: B {
// void f(); // illformed
// void g() throw (int); // OK
// };
public void test15_4s3a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class A { };
// void (*pf1)(); // no exception specification
// void (*pf2)() throw(A);
// void f()
// {
// pf1 = pf2; // OK: pf1 is less restrictive
// pf2 = pf1; // error: pf2 is more restrictive
// }
public void test15_4s3b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class X { };
// class Y { };
// class Z: public X { };
// class W { };
// void f() throw (X, Y)
// {
// int n = 0;
// if (n) throw X(); // OK
// if (n) throw Z(); // also OK
// throw W(); // will call unexpected()
// }
public void test15_4s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// extern void f() throw(X, Y);
// void g() throw(X)
// {
// // f(); //OK
// }
public void test15_4s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A {
// A();
// A(const A&) throw();
// ~A() throw(X);
// };
// struct B {
// B() throw();
// B(const B&) throw();
// ~B() throw(Y);
// };
// struct D : public A, public B {
// // Implicit declaration of D::D();
// // Implicit declaration of D::D(const D&) throw();
// // Implicit declaration of D::~D() throw (X,Y);
// };
public void test15_4s13() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// #if VERSION == 1
// #define INCFILE "vers1.h"
// #elif VERSION == 2
// #define INCFILE "vers2.h" // and so on
// #else
// #define INCFILE "versN.h"
// #endif
public void test16_2s8() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // second pass of C++ spec is to get [Note: ]
// int f() {
// int a, b;
// /*...*/
// a = a + 32760 + b + 5;
// a = (((a + 32760) + b) + 5);
// a = ((a + b) + 32765);
// a = ((a + 32765) + b);
// a = (a + (b + 32765));
// }
public void test18_2_1_5s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct X {
// enum E { z = 16 };
// int b[X::z]; // OK
// };
public void test3_3_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int f;
// struct A {
// friend void f(A &);
// operator int();
// void g(A a) {
// f(a);
// }
// };
public void test3_4_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A {
// int a;
// };
// struct B: virtual A { };
// struct C: B { };
// struct D: B { };
// struct E: public C, public D { };
// struct F: public A { };
// void f() {
// E e;
// e.B::a = 0; // OK, only one A::a in E
// F f;
// f.A::a = 1; // OK, A::a is a member of F
// }
public void test3_4_5s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// inline double fd() { return 1.0; }
// extern double d1;
// double d2 = d1; // unspecified:
// // may be statically initialized to 0.0 or
// // dynamically initialized to 1.0
// double d1 = fd(); // may be initialized statically to 1.0
public void test3_6_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int main() {
// const char c = 'c';
// char* pc;
// const char** pcc = &pc; //1: not allowed
// *pcc = &c;
// *pc = 'C'; //2: modifies a const object
// }
public void test4_4s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct S {
// mutable int i;
// };
// int f() {
// const S cs;
// int S::* pm = &S::i; // pm refers to mutable member S::i
// cs.*pm = 88; // illformed: cs is a const object
// }
public void test5_5s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace A {
// class X { };
// extern "C" int g();
// extern "C++" int h();
// }
// namespace B {
// void X(int);
// extern "C" int g();
// extern "C++" int h();
// }
// using namespace A;
// using namespace B;
// void f() {
// X(1); //error: name X found in two namespaces
// g(); //okay: name g refers to the same entity
// h(); //error: name h found in two namespaces
// }
public void test7_3_4s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// int a;
// const int b = a;
// int c = b;
public void test8_5s14() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual void f();
// };
// struct D : B {
// void f(int);
// };
// struct D2 : D {
// void f();
// };
public void test10_3s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct B {
// virtual ~B();
// void operator delete(void*, size_t);
// };
// struct D : B {
// void operator delete(void*);
// };
// void f()
// {
// B* bp = new D;
// delete bp; //1: uses D::operator delete(void*)
// }
public void test12_5s7a() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct B {
// virtual ~B();
// void operator delete[](void*, size_t);
// };
// struct D : B {
// void operator delete[](void*, size_t);
// };
// void f(int i)
// {
// D* dp = new D[i];
// delete [] dp; // uses D::operator delete[](void*, size_t)
// B* bp = new D[i];
// delete[] bp; // undefined behavior
// }
public void test12_5s7b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// struct A { };
// void operator + (A, A);
// struct B {
// void operator + (B);
// void f ();
// };
// A a;
// void B::f() {
// //operator+ (a,a); // ERROR - global operator hidden by member
// a + a; // OK - calls global operator+
// }
public void test13_3_1_2s10() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> class myarray { };
// template<class K, class V, template<class T> class C = myarray>
// class Map {
// C<K> key;
// C<V> value;
// // ...
// };
public void test14_1s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// class T { };
// int i;
// template<class T, T i> void f(T t)
// {
// T t1 = i; // templateparameters T and i
// ::T t2 = ::i; // global namespace members T and i
// }
public void test14_1s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<int* p> class X { };
// int a[10];
// struct S { int m; static int s; } s;
// X<&a[2]> x3; // error: address of array element
// X<&s.m> x4; // error: address of nonstatic member
// X<&s.s> x5; // error: &S::s must be used
// X<&S::s> x6; // OK: address of static member
public void test14_3_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T, char* p> class X {
// // ...
// X();
// X(const char* q) { }
// };
// X<int,"Studebaker"> x1; // error: string literal as template argument
// char p[] = "Vivisectionist";
// X<int,p> x2; // OK
public void test14_3_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<const int& CRI> struct B { /* ... */ };
// B<1> b2; // error: temporary would be required for template argument
// int c = 1;
// B<c> b1; // OK
public void test14_3_2s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<const int* pci> struct X { };
// int ai[10];
// X<ai> xi; // array to pointer and qualification conversions
// struct Y { };
// template<const Y& b> struct Z { };
// Y y;
// Z<y> z; // no conversion, but note extra cvqualification
// template<int (&pa)[5]> struct W { };
// int b[5];
// W<b> w; // no conversion
// void f(char);
// void f(int);
// template<void (*pf)(int)> struct A { };
// A<&f> a; // selects f(int)
public void test14_3_2s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <class T> struct A {
// void f(int);
// template <class T2> void f(T2);
// };
// template <> void A<int>::f(int) { } // nontemplate member
// template <> template <> void A<int>::f<>(int) { } // template member
// int main()
// {
// A<char> ac;
// ac.f(1); //nontemplate
// ac.f('c'); //template
// ac.f<>(1); //template
// }
public void test14_5_2s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0); //should be 0
}
// template<class T1, class T2, int I> class A<T1, T2, I> { }; // error
public void test14_5_5s5() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> struct A {
// class C {
// template<class T2> struct B { };
// };
// };
// // partial specialization of A<T>::C::B<T2>
// template<class T> template<class T2>
// struct A<T>::C::B<T2*> { };
// A<short>::C::B<int*> absip; // uses partial specialization
public void test14_5_5s6() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// namespace N {
// template<class T1, class T2> class A { }; // primary template
// }
// using N::A; // refers to the primary template
// namespace N {
// template<class T> class A<T, T*> { }; // partial specialization
// }
// A<int,int*> a; // uses the partial specialization, which is found through
// // the using declaration which refers to the primary template
public void test14_5_5s7() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template<class T> void f();
// template<int I> void f(); // OK: overloads the first template
// // distinguishable with an explicit template argument list
public void test14_5_6_1s4() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// template <int I> class A;
// template <int I, int J> A<I+J> f/*1*/(A<I>, A<J>); // #1
// template <int K, int L> A<K+L> f/*2*/(A<K>, A<L>); // same as #1
// template <int I, int J> A<I-J> f/*3*/(A<I>, A<J>); // different from #1
public void test14_5_6_1s5() throws Exception {
final String content= getAboveComment();
IASTTranslationUnit tu= parse(content, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
ICPPFunctionTemplate f1= bh.assertNonProblem("f/*1*/", 1);
ICPPFunctionTemplate f2= bh.assertNonProblem("f/*2*/", 1);
ICPPFunctionTemplate f3= bh.assertNonProblem("f/*3*/", 1);
assertSame(f1, f2);
assertNotSame(f1, f3);
}
// template <int I> class A;
// template <int I, int J> void f/*1*/(A<I+J>); // #1
// template <int K, int L> void f/*2*/(A<K+L>); // same as #1
public void test14_5_6_1s6() throws Exception {
final String content= getAboveComment();
IASTTranslationUnit tu= parse(content, ParserLanguage.CPP, true, 0);
BindingAssertionHelper bh= new BindingAssertionHelper(content, true);
ICPPFunctionTemplate f1= bh.assertNonProblem("f/*1*/", 1);
ICPPFunctionTemplate f2= bh.assertNonProblem("f/*2*/", 1);
assertSame(f1, f2);
}
// template <class T> int f(T); // #1
// int f(int); // #2
// int k = f(1); // uses #2
// int l = f<>(1); // uses #1
public void test14_8_1s2b() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// #define TABSIZE 100
// int table[TABSIZE];
public void test15_3_5s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int g(int);
// void f()
// {
// int i;
// int& r = i; // r refers to i
// r = 1; // the value of i becomes 1
// int* p = &r; // p points to i
// int& rr = r; // rr refers to what r refers to, that is, to i
// int (&rg)(int) = g; // rg refers to the function g
// rg(i); //calls function g
// int a[3];
// int (&ra)[3] = a; // ra refers to the array a
// ra[1] = i; // modifies a[1]
// }
public void test8_5_3s1() throws Exception { // TODO raised bug 90648
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A { }; // implicitlydeclared A::operator=
// struct B : A {
// B& operator=(const B &);
// };
// B& B::operator=(const B& s) {
// this->A::operator=(s); // wellformed
// return *this;
// }
public void test12s1() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// struct A { };
// struct B : virtual A { };
// struct C : B { };
// struct D : virtual A { D(A*); };
// struct X { X(A*); };
// struct E : C, D, X {
// E() : D(this), // undefined: upcast from E* to A*
// // might use path E* -> D* -> A*
// // but D is not constructed
// // D((C*)this), // defined:
// // E* -> C* defined because E() has started
// // and C* -> A* defined because
// // C fully constructed
// X(this) //defined: upon construction of X,
// // C/B/D/A sublattice is fully constructed
// { }
// };
public void test12_7s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// typedef int c;
// enum { i = 1 };
// class X {
// int i=3;
// char v[i];
// int f() { return sizeof(c); } // OK: X::c
// char c;
// enum { i = 2 };
// };
// typedef char* T;
// struct Y {
// typedef long T;
// T b;
// };
// typedef int I;
// class D {
// typedef I I; // error, even though no reordering involved
// };
public void test3_3_6s5() throws Exception { // 90606
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// int f(double);
// int f(int);
// int (*pfd)(double) = &f; // selects f(double)
// int (*pfi)(int) = &f; // selects f(int)
// int (*pfe)(...) = &f; // error: type mismatch
// int (&rfi)(int) = f; // selects f(int)
// int (&rfd)(double) = f; // selects f(double)
// void g() {
// (int (*)(int))&f; // cast expression as selector
// }
public void test13_4s5a() throws Exception { // bug 90674
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// class A {
// public:
// int z;
// int z1;
// };
// class B : public A {
// int a;
// public:
// int b, c;
// int bf();
// protected:
// int x;
// int y;
// };
// class D : private B {
// int d;
// public:
// B::c; //adjust access to B::c
// B::z; //adjust access to A::z
// A::z1; //adjust access to A::z1
// int e;
// int df();
// protected:
// B::x; //adjust access to B::x
// int g;
// };
// class X : public D {
// int xf();
// };
// int ef(D&);
// int ff(X&);
public void test11_3s2() throws Exception { //bug 92793
IASTTranslationUnit tu= parse(getAboveComment(), ParserLanguage.CPP, true, 0);
IASTCompositeTypeSpecifier D= getCompositeType(tu, 2);
IASTDeclaration accessDecl= getDeclaration(D, 2);
assertInstance(accessDecl, ICPPASTUsingDeclaration.class);
}
// int z() {
// int f(int);
// int a = 2;
// int b = f(a);
// int c(b);
// }
public void test8_5s2() throws Exception { // 90641
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
// // #include <cstddef>
// char *p;
// void *operator new(size_t, int);
// void foo() {
// const int x = 63;
// new (int(*p)) int; // newplacement expression
// new (int(*[x])); // new typeid
// }
public void test8_2s3() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, false, 0);
}
// template<class T> void f();
// template<int I> void f();
// void g()
// {
// f<int()>(); // int() is a typeid:call the first f()
// }
public void test14_3s2() throws Exception {
parse(getAboveComment(), ParserLanguage.CPP, true, 0);
}
}