import java.io.IOException;
-import junit.framework.TestSuite;
-
import org.eclipse.cdt.core.dom.IName;
import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
import org.eclipse.cdt.core.dom.ast.IASTBinaryExpression;
import org.eclipse.cdt.internal.core.dom.parser.cpp.semantics.SemanticUtil;
import org.eclipse.cdt.internal.core.parser.ParserException;
+import junit.framework.TestSuite;
+
public class AST2TemplateTests extends AST2TestBase {
public AST2TemplateTests() {
assertInstances(col, T1, 6);
}
-
+
// template<typename _A_>
// struct A : public _A_::member_t {};
//
public void testTemplateAmbiguityInDeleteExpression_364225() throws Exception {
parseAndCheckBindings();
}
-
+
// template<int, int> struct a {};
// const int b = 0, c = 1;
// int a<b<c,b<c>::*mp6; // syntax error here
assertEquals("bool", ASTTypeUtil.getType(td.getType()));
ah.assertProblem("B<int*>::type", "type");
}
-
+
// constexpr int f() { return 1; }
//
// template <int>
public void testSfinaeInTemplatedConversionOperator_409056() throws Exception {
parseAndCheckImplicitNameBindings();
}
-
+
// template<typename T>
// struct A {
// static constexpr bool value = false;
// static int test(...);
//
// struct A {
- // A() = delete;
+ // A() = delete;
// };
//
// int waldo(int p);
public void testSfinaeInNewExpressionWithDeletedConstructor_430230() throws Exception {
parseAndCheckBindings();
}
-
+
// template<typename _From>
// struct is_convertible {};
//
public void testSfinaeInIdExpression_459940() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename>
// struct M {
// template <typename... Args>
public void testVariadicTemplatesAndFunctionObjects_401479() throws Exception {
parseAndCheckBindings();
}
-
+
// template<typename _Tp>
// _Tp declval() noexcept;
//
BindingAssertionHelper helper = new BindingAssertionHelper(getAboveComment(), true);
helper.assertProblem("bind(s, 0, foo)", "bind");
}
-
+
// struct a3 {
// int xxx;
// };
public void testParameterPackInNestedTemplate_441028() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename... Args>
// void waldo(Args...);
//
BindingAssertionHelper helper = getAssertionHelper();
helper.assertProblem("waldo<int>()", "waldo<int>");
}
-
+
// // Example 1
// template <typename... T>
// void foo1(T... t) {
// }
//
// // Example 2
- // template <typename> struct A {};
+ // template <typename> struct A {};
// template <typename... T>
// void foo2(A<T>... t) {
// bar(t.waldo...);
public void testUnqualifiedFunctionCallInTemplate_402498a() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename T>
// auto foo(T t) -> decltype(bar(t));
//
public void testUnqualifiedFunctionCallInTemplate_458316a() throws Exception {
parseAndCheckBindings();
}
-
+
// void bar();
//
// template <typename T>
public void testUnqualifiedFunctionCallInTemplate_458316b() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename>
// struct no_type {};
//
BindingAssertionHelper helper = getAssertionHelper();
helper.assertNonProblem("waldo<T>", ICPPDeferredFunction.class);
}
-
+
// template <typename>
// struct C {
// friend bool operator==(C, C);
public void testStrayFriends_419301() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename T>
// constexpr T t(T) {
// return 0;
ICPPVariable waldo = helper.assertNonProblem("waldo");
assertConstantValue(2, waldo);
}
-
+
// struct Test {
// static constexpr unsigned calc_sig(const char *s, unsigned n) {
// return (n == 0 || *s == '\0' ? 0 :
public void testConstexprFunctionCallWithNonConstexprArguments_429891() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename> class A {};
// template <int> class B {};
// const int D = 4;
public void testLocalTypeAsTemplateArgument_442832() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename T>
// struct Bar {};
//
// Bar<decltype(t.foo)> bar; // bogus `invalid template arguments` error here
// return bar;
// }
- //
+ //
// struct S {
// int foo;
// };
- //
+ //
// int main() {
// Bar<int> var1;
// auto var2 = foo(S());
IVariable var2 = helper.assertNonProblem("var2");
assertSameType(var1.getType(), var2.getType());
}
-
+
// template <bool>
// struct integral_constant {
// static const bool value = true;
public void testClassSpecializationInEnumerator_457511() throws Exception {
parseAndCheckBindings();
}
-
+
// template <typename> struct TypeTemplate {};
// template <int> struct Size_tTemplate {};
//
import java.util.ArrayList;
import java.util.List;
-import junit.framework.TestSuite;
-
import org.eclipse.cdt.core.dom.ast.ASTTypeUtil;
import org.eclipse.cdt.core.dom.ast.EScopeKind;
import org.eclipse.cdt.core.dom.ast.IASTName;
import org.eclipse.cdt.internal.core.index.IIndexScope;
import org.eclipse.core.runtime.CoreException;
+import junit.framework.TestSuite;
+
/**
* Tests for exercising resolution of template bindings against IIndex
*/
// struct A {
// typedef T t;
// };
-
+
// template<typename T>
// struct B {};
//
public void testNPE_407497() throws Exception {
checkBindings();
}
-
+
// template <typename>
// struct basic_A {
// bool eof() const;
// };
//
// typedef basic_A<char> A;
-
+
// class B : public A {};
//
// class C : public A, public B {};
public void testFriendFunctionOfClassSpecialization_419301b() throws Exception {
checkBindings();
}
-
+
// template <typename T>
// constexpr T t(T) {
// return 0;
// constexpr unsigned t<unsigned>(unsigned) {
// return 1 + 1;
// }
-
+
// // empty source file
public void testSpecializationOfConstexprFunction_420995() throws Exception {
checkBindings();
}
-
+
// template <class TYPE>
// class waldo {
// enum {
//
// template <>
// struct meta<int> {};
-
+
// int z;
public void testEnumerationWithMultipleEnumerators_434467() throws Exception {
checkBindings();
}
-
+
// template <typename ResultT, ResultT (*Func)()>
// struct Base {
// ResultT operator()() const;
// };
- //
+ //
// struct S {};
- //
+ //
// template <typename T>
// class B {};
- //
+ //
// template<typename T>
// B<T> f();
- //
+ //
// template <typename T>
// class Derived : public Base<B<S>, f<T> > {};
// const Derived<S> decl;
- //
+ //
// void bar(const B<S>&);
- //
+ //
// void foo() {
// bar(decl()); // ERROR HERE: Invalid arguments
// }
public void testInstantiationOfFunctionInstance_437675() throws Exception {
checkBindings();
}
-
+
// struct IID { };
- //
+ //
// struct IUnknown {};
- //
+ //
// template<class T>
// class IID_DUMMY : IID { };
- //
+ //
// template<class T>
// const IID &__uuidof(T x) { return IID_DUMMY<T>(); }
//
//
// template <class T, const IID* piid = &__uuidof<T> >
// class MYCComQIPtr : public MYCComPtr<T> {};
- //
+ //
// template<>
// class MYCComQIPtr<IUnknown, &IID_IUnknown> : public MYCComPtr<IUnknown> {};
-
+
// // source file is deliberately empty
public void testInfiniteRecursionMarshallingTemplateDefinition_439923() throws Exception {
checkBindings();
}
-
-
+
// template <typename T>
// struct Bar {};
//
// Bar<decltype(t.foo)> bar; // bogus `invalid template arguments` error here
// return bar;
// }
- //
+ //
// struct S {
// int foo;
// };
-
+
// int main() {
// Bar<int> var1;
// auto var2 = foo(S());