core/org.eclipse.cdt.ui.tests/ui/org/eclipse/cdt/ui/tests/text/contentassist2/PlainC_CompletionTests.java

/*******************************************************************************
 * Copyright (c) 2007, 2014 Wind River Systems, Inc. and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     Anton Leherbauer (Wind River Systems) - initial API and implementation
 *     Markus Schorn (Wind River Systems)
 *     IBM Corporation
 *     Jens Elmenthaler - http://bugs.eclipse.org/173458 (camel case completion)
 *******************************************************************************/
package org.eclipse.cdt.ui.tests.text.contentassist2;

import org.eclipse.cdt.core.CCorePlugin;
import org.eclipse.cdt.core.testplugin.util.BaseTestCase;
import org.eclipse.core.resources.IFile;
import org.eclipse.core.resources.IProject;
import org.eclipse.jface.text.IDocument;

import junit.framework.Test;

/**
 * Completion tests for plain C.
 *
 * @since 4.0
 */
public class PlainC_CompletionTests extends AbstractContentAssistTest {

	private static final String HEADER_FILE_NAME = "CompletionTest.h";
	private static final String SOURCE_FILE_NAME = "CompletionTest.c";
	private static final String CURSOR_LOCATION_TAG = "/*cursor*/";
	private static final String INCLUDE_LOCATION_TAG = "/*include*/";
	private static final String DISTURB_FILE_NAME = "DisturbWith.c";

	protected int fCursorOffset;
	private IProject fProject;

	//{CompletionTest.h}
	//int gGlobalInt;
	//struct Struct1;
	//struct Struct2;
	//union Union1;
	//union Union2;
	//
	//#define DEBUG 1
	//#define AMacro(x) x+1
	//#define XMacro(x,y) x+y
	//
	//int aVariable;
	//int xVariable;
	//
	//void aFunction();
	//void xFunction();
	//
	//enum anEnumeration {
	//	aFirstEnum,
	//	aSecondEnum,
	//	aThirdEnum
	//};
	//typedef enum anEnumeration anEnumerationType;
	//
	//enum xEnumeration {
	//	xFirstEnum,
	//	xSecondEnum,
	//	xThirdEnum
	//};
	//typedef enum xEnumeration xEnumerationType;
	//
	//struct AStruct{
	//	int aStructField;
	//	int xaStructField;
	//};
	//typedef struct AStruct AStructType;
	//
	//struct XStruct{
	//	int xStructField;
	//	int axStructField;
	//};
	//typedef struct XStruct XStructType;
	//
	//void anotherFunction(){
	//   int aLocalDeclaration = 1;
	//}
	//
	//void xOtherFunction(){
	//   int xLocalDeclaration = 1;
	//}
	//#ifdef ANONYMOUS
	//enum {
	//	anonFirstEnum,
	//	anonSecondEnum,
	//	anonThirdEnum
	//};
	//
	//enum {
	//	xanonFirstEnum,
	//	xanonSecondEnum,
	//	xanonThirdEnum
	//};
	//
	//int notAnonymous;
	//enum notAnonymousEnum {};
	//struct notAnonymousStruct {};
	//
	//struct {
	//	int anonStructField;
	//};
	//
	//struct {
	//	int xanonStructField;
	//};
	//
	//union {
	//	int anonUnionMember1, anonUnionMember2;
	//};
	//#endif /* ANONYMOUS */
	//
	//#ifdef STRUCT_C1
	//enum E1 {e11, e12};
	//
	//struct C1_s {
	//  enum E2 {e21, e22};
	//
	//  struct C1_s* fMySelf;
	//
	//  int m123;
	//  int m12;
	//  int m13;
	//};
	//typedef struct C1_s C1;
	//extern C1* gfC1();
	//C1* gfC2();
	//C1 gC1, gC2;
	//#endif /* STRUCT_C1 */
	//	struct s206450 {
	//		struct {int a1; int a2;};
	//		union {int u1; char u2;};
	//		struct {int a3;} a4;
	//		int b;
	//	};
	// #ifdef bug204758
	// typedef enum {__nix} _e204758;
	// void _f204758(_e204758 x);
	// #endif

	//{DisturbWith.c}
	// int gTemp;
	// void gFunc();
	// typedef struct {
	//    int mem;
	// } gStruct;

	public static Test suite() {
		return BaseTestCase.suite(PlainC_CompletionTests.class, "_");
	}

	/**
	 * @param name
	 */
	public PlainC_CompletionTests(String name) {
		super(name, false);
	}

	/*
	 * @see org.eclipse.cdt.ui.tests.text.contentassist2.AbstractContentAssistTest#setUpProjectContent(org.eclipse.core.resources.IProject)
	 */
	@Override
	protected IFile setUpProjectContent(IProject project) throws Exception {
		fProject = project;
		String headerContent = readTaggedComment(HEADER_FILE_NAME);
		StringBuilder sourceContent = getContentsForTest(1)[0];
		int includeOffset = Math.max(0, sourceContent.indexOf(INCLUDE_LOCATION_TAG));
		sourceContent.insert(includeOffset, "#include \"" + HEADER_FILE_NAME + "\"\n");
		fCursorOffset = sourceContent.indexOf(CURSOR_LOCATION_TAG);
		assertTrue("No cursor location specified", fCursorOffset >= 0);
		sourceContent.delete(fCursorOffset, fCursorOffset + CURSOR_LOCATION_TAG.length());
		assertNotNull(createFile(project, HEADER_FILE_NAME, headerContent));
		IFile sourceFile = createFile(project, SOURCE_FILE_NAME, sourceContent.toString());
		// re-indexing is necessary to parse the header in context of the source.
		CCorePlugin.getIndexManager().reindex(fCProject);
		waitForIndexer(fCProject);
		return sourceFile;
	}

	protected static final int DEFAULT_FLAGS = AbstractContentAssistTest.DEFAULT_FLAGS | IS_COMPLETION;

	protected void assertCompletionResults(String[] expected) throws Exception {
		assertContentAssistResults(fCursorOffset, expected, DEFAULT_FLAGS, CompareType.ID);
	}

	//void test() {
	//  int myvar;
	//  (my/*cursor*/
	public void testLocalVariableAfterOpeningParen_Bug180885() throws Exception {
		final String[] expected = { "myvar" };
		assertCompletionResults(expected);
	}

	//void test() {
	//  int myvar;
	//  int x = my/*cursor*/
	public void testLocalVariableInAssignment() throws Exception {
		final String[] expected = { "myvar" };
		assertCompletionResults(expected);
	}

	//void test() {
	//  int myvar;
	//  my/*cursor*/
	public void testLocalVariableOnLHS() throws Exception {
		final String[] expected = { "myvar" };
		assertCompletionResults(expected);
	}

	// void test() {
	//    g/*cursor*/
	public void testBindingsWithoutDeclaration() throws Exception {
		// gStruct: fix for 214146, type from a source file is not proposed.
		final String[] expected = { "gGlobalInt", "gTemp", "gFunc(void)", };
		final String[] expected2 = { "gGlobalInt" };
		String disturbContent = readTaggedComment(DISTURB_FILE_NAME);
		IFile dfile = createFile(fProject, DISTURB_FILE_NAME, disturbContent);
		waitForIndexer(fCProject);
		assertCompletionResults(expected);

		dfile.delete(true, npm());
		waitForIndexer(fCProject);
		assertCompletionResults(expected2);
	}

	//// to_be_replaced_
	//void gfunc(){aNew/*cursor*/
	public void testGlobalVariableBeforeSave_Bug180883() throws Exception {
		String replace = "// to_be_replaced_";
		String globalVar = "int aNewGlobalVar;";
		IDocument doc = getDocument();
		int idx = doc.get().indexOf(replace);
		doc.replace(idx, replace.length(), globalVar);

		final String[] expected = { "aNewGlobalVar" };
		assertCompletionResults(expected);
	}

	// static int staticVar197990;
	// void gFunc() {
	//   stat/*cursor*/
	public void testStaticVariables_Bug197990() throws Exception {
		final String[] expected = { "staticVar197990" };
		assertCompletionResults(expected);
	}

	// struct Struct/*cursor*/
	public void testElaboratedTypeSpecifierStruct_bug208710() throws Exception {
		final String[] expected = { "Struct1", "Struct2" };
		assertCompletionResults(expected);
	}

	// struct Union/*cursor*/
	public void testElaboratedTypeSpecifierNotStruct_bug208710() throws Exception {
		final String[] expected = new String[0];
		assertCompletionResults(expected);
	}

	// union Union/*cursor*/
	public void testElaboratedTypeSpecifierUnion_bug208710() throws Exception {
		final String[] expected = { "Union1", "Union2" };
		assertCompletionResults(expected);
	}

	// union Struct/*cursor*/
	public void testElaboratedTypeSpecifierNotUnion_bug208710() throws Exception {
		final String[] expected = new String[0];
		assertCompletionResults(expected);
	}

	// void func() {float a; a= 1./*cursor*/}
	public void testCompletionInFloatingPointLiteral_Bug193464() throws Exception {
		final String[] expected = new String[0];
		assertCompletionResults(expected);
	}

	// #ifdef __cplusplus__
	// extern "C" {
	// #endif
	// void c_linkage();
	// #ifdef __cplusplus__
	// }
	// #endif

	// #include "header191315.h"

	// #include "header191315.h"
	// void xxx() { c_lin/*cursor*/
	public void testExternC_bug191315() throws Exception {
		CharSequence[] content = getContentsForTest(3);
		createFile(fProject, "header191315.h", content[0].toString());
		createFile(fProject, "source191315.c", content[1].toString());
		createFile(fProject, "source191315.cpp", content[1].toString());
		waitForIndexer(fCProject);
		final String[] expected = { "c_linkage(void)" };
		assertCompletionResults(expected);
	}

	//#define ANONYMOUS
	///*include*/
	///*cursor*/
	public void testAnonymousTypes() throws Exception {
		final String[] expected = { "AStructType", "XStructType", "anEnumerationType", "xEnumerationType" };
		assertCompletionResults(expected);
	}

	//void foo ( a/*cursor*/
	public void testArgumentTypes_Prefix() throws Exception {
		final String[] expected = { "AMacro(x)", "AStructType", "anEnumerationType" };
		assertCompletionResults(expected);
	}

	//struct aThirdStruct {
	//   int x;
	//   /*cursor*/
	//};
	public void testFieldType_NoPrefix() throws Exception {
		final String[] expected = { "AStructType", "XStructType", "anEnumerationType", "xEnumerationType" };
		assertCompletionResults(expected);
	}

	//struct aThirdStruct {
	//   int x;
	//   a/*cursor*/
	//};
	public void testFieldType_Prefix() throws Exception {
		final String[] expected = { "AMacro(x)", "AStructType", "anEnumerationType" };
		assertCompletionResults(expected);
	}

	//#ifdef /*cursor*/
	public void testMacroRef_NoPrefix() throws Exception {
		final String[] expected = { "AMacro(x)", "DEBUG", "XMacro(x, y)", "__CDT_PARSER__", "__COUNTER__", "__DATE__",
				"__FILE__", "__LINE__", "__STDC_HOSTED__", "__STDC_VERSION__", "__STDC__", "__TIME__",
				"__builtin_va_arg(ap, type)", "__builtin_offsetof(T, m)", "__builtin_types_compatible_p(x, y)",
				"__complex__", "__extension__", "__has_include", "__has_include_next", "__imag__", "__null",
				"__offsetof__(x)", "__real__", "__stdcall", "__thread", };
		assertCompletionResults(expected);
	}

	//#ifdef D/*cursor*/
	public void testMacroRef_Prefix() throws Exception {
		final String[] expected = { "DEBUG" };
		assertCompletionResults(expected);
	}

	//	int waldo;
	//	void foo() {
	//	#ifdef SOME_UNDEFINED_MACRO
	//		wald/*cursor*/
	//	#endif
	//	}
	public void testInactiveCodeBlock_72809() throws Exception {
		assertCompletionResults(new String[] { "waldo" });
	}

	//void fooFunction()
	//{
	//    AStructType* c;
	//    c->/*cursor*/
	//}
	public void testMemberReference_Arrow_NoPrefix() throws Exception {
		final String[] expected = { "aStructField", "xaStructField", };
		assertCompletionResults(expected);
	}

	//void main() {
	//    struct AStruct a, *ap;
	//    ap->/*cursor*/
	//}
	public void testMemberReference_Arrow_NoPrefix2() throws Exception {
		final String[] expected = { "aStructField", "xaStructField", };
		assertCompletionResults(expected);
	}

	//void fooFunction()
	//{
	//    AStructType* c;
	//    c->a/*cursor*/
	//}
	public void testMemberReference_Arrow_Prefix() throws Exception {
		final String[] expected = { "aStructField", };
		assertCompletionResults(expected);
	}

	//AStructType* foo();
	//
	//void fooFunction()
	//{
	//    foo()->a/*cursor*/
	//}
	public void testMemberReference_Arrow_Prefix2() throws Exception {
		final String[] expected = { "aStructField", };
		assertCompletionResults(expected);
	}

	//void fooFunction()
	//{
	//    AStructType c;
	//    c./*cursor*/
	//}
	public void testMemberReference_Dot_NoPrefix() throws Exception {
		final String[] expected = { "aStructField", "xaStructField", };
		assertCompletionResults(expected);
	}

	//void fooFunction()
	//{
	//    AStructType c;
	//    c.a/*cursor*/
	//}
	public void testMemberReference_Dot_Prefix() throws Exception {
		final String[] expected = { "aStructField", };
		assertCompletionResults(expected);
	}

	//typedef int myType;
	//
	//m/*cursor*/
	public void testTypeDef_Prefix() throws Exception {
		final String[] expected = { "myType", };
		assertCompletionResults(expected);
	}

	//void fooFunction(int x)
	//{
	//    /*cursor*/
	//}
	public void testSingleName_Function_NoPrefix() throws Exception {
		final String[] expected = { "x", "aVariable", "xVariable", "aFunction(void)", "anotherFunction(void)",
				"fooFunction(int)", "xFunction(void)", "xOtherFunction(void)", "anEnumerationType", "xEnumerationType",
				"AStructType", "XStructType", "aFirstEnum", "aSecondEnum", "aThirdEnum", "xFirstEnum", "xSecondEnum",
				"xThirdEnum", "gGlobalInt" };
		assertCompletionResults(expected);
	}

	//void fooFunction(int x)
	//{
	//    a/*cursor*/
	//}
	public void testSingleName_Function_Prefix() throws Exception {
		final String[] expected = { "AMacro(x)", "AStructType", "aVariable", "aFunction(void)", "anotherFunction(void)",
				"anEnumerationType", "aFirstEnum", "aSecondEnum", "aThirdEnum", };
		assertCompletionResults(expected);
	}

	//void fooFunction(int x)
	//{
	//    int y = /*cursor*/
	//}
	public void testSingleName_Assignment_NoPrefix() throws Exception {
		final String[] expected = { "x", "y", "aVariable", "xVariable", "aFunction(void)", "anotherFunction(void)",
				"fooFunction(int)", "xFunction(void)", "xOtherFunction(void)", "anEnumerationType", "xEnumerationType",
				"AStructType", "XStructType", "aFirstEnum", "aSecondEnum", "aThirdEnum", "xFirstEnum", "xSecondEnum",
				"xThirdEnum", "gGlobalInt" };
		assertCompletionResults(expected);
	}

	//void foo(int x)
	//{
	//    int y = AM/*cursor*/
	//}
	public void testSingleName_Assignment_Prefix() throws Exception {
		final String[] expected = { "AMacro(x)" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void gfunc() {C1 v; v.m/*cursor*/
	public void testLocalVariable() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void gfunc() {C1 v; v.fMySelf->m/*cursor*/
	public void testLocalVariable_MemberVariable() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void gfunc() {gfC1()->m/*cursor*/
	public void testGlobalFunction() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {gC/*cursor*/
	public void testGlobalVariables_GlobalScope() throws Exception {
		final String[] expected = { "gC1", "gC2", "gfC1(void)", "gfC2(void)" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void foo() {gC/*cursor*/
	public void testGlobalVariables_FunctionScope() throws Exception {
		final String[] expected = { "gC1", "gC2", "gfC1(void)", "gfC2(void)" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//typedef struct {
	//  enum E2 {e21, e22};
	//
	//  C2* fMySelf;
	//
	//  int m123;
	//  int m12;
	//  int m13;
	//} C2;
	//void f() {C2* cLocal1; while(true) {C1* cLocal2; cL/*cursor*/
	public void testLocalVariables_FunctionScope() throws Exception {
		final String[] expected = { "cLocal1", "cLocal2" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* cLocal1; cLocal1->f/*cursor*/
	public void testDataMembers_FunctionScope() throws Exception {
		final String[] expected = { "fMySelf" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {gf/*cursor*/
	public void testGlobalFunctions_FunctionScope() throws Exception {
		final String[] expected = { "gfC1(void)", "gfC2(void)" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//typedef struct {} C2;
	//typedef union {} C3;
	//void f() {C/*cursor*/
	public void testTypes_FunctionScope() throws Exception {
		final String[] expected = { "C1", "C2", "C3" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {e/*cursor*/
	public void testEnums_FunctionScope() throws Exception {
		final String[] expected = { "e11", "e12", "e21", "e22" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1 c; (&c)->m/*cursor*/
	public void testAddressOf() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; (*c).m/*cursor*/
	public void testDereferencingOperator1() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1** c; (**c).m/*cursor*/
	public void testDereferencingOperator2() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1** c; (*c)->m/*cursor*/
	public void testDereferencingOperator3() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; c[0].m/*cursor*/
	public void testArrayAccessOperator1() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1** c; c[0][1].m/*cursor*/
	public void testArrayAccessOperator2() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1** c; c[0]->m/*cursor*/
	public void testArrayAccessOperator3() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; (&c[0])->m/*cursor*/
	public void testArrayAccessOperator4() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {void* c; ((C1*)c)->m/*cursor*/
	public void testCasts1() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void g(int a) {}; void f() {void* c; g(((C1*)c)->m/*cursor*/
	public void testCasts2() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; c++->m/*cursor*/
	public void testPointerArithmetic1() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; (*++c).m/*cursor*/
	public void testPointerArithmetic2() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1* c; c--->m/*cursor*/
	public void testPointerArithmetic3() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1 c; (&c+1)->m/*cursor*/
	public void testPointerArithmetic4() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {C1 c; (&c-1)->m/*cursor*/
	public void testPointerArithmetic5() throws Exception {
		final String[] expected = { "m123", "m12", "m13" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//void f() {int localVar=0; if (*cond && somefunc(&local/*cursor*/
	public void testNestedCalls() throws Exception {
		final String[] expected = { "localVar" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//int a[] = {1,2}; void f(int _0306_b) {_0306_b/*cursor*/
	public void testCuttingInput1() throws Exception {
		final String[] expected = { "_0306_b" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//int a[] = {1,2}; void f(int b) {int _0306_b[] = {2,3}; _0306_b/*cursor*/
	public void testCuttingInput2() throws Exception {
		final String[] expected = { "_0306_b" };
		assertCompletionResults(expected);
	}

	//#define STRUCT_C1
	///*include*/
	//enum EnumType function() {int _031209_v; _031209/*cursor*/
	public void testDisturbingMacros() throws Exception {
		final String[] expected = { "_031209_v" };
		assertCompletionResults(expected);
	}

	// void test() {
	// int local;
	// switch(loc/*cursor*/
	public void testSwitchStatement() throws Exception {
		final String[] expected = { "local" };
		assertCompletionResults(expected);
	}

	// void test() {
	// int local;
	// while(loc/*cursor*/
	public void testWhileStatement() throws Exception {
		final String[] expected = { "local" };
		assertCompletionResults(expected);
	}

	// void test() {
	// int local;
	// for(loc/*cursor*/
	public void testForStatement1() throws Exception {
		final String[] expected = { "local" };
		assertCompletionResults(expected);
	}

	// void test() {
	// int local;
	// for(int i=0;i<loc/*cursor*/
	public void testForStatement2() throws Exception {
		final String[] expected = { "local" };
		assertCompletionResults(expected);
	}

	// void test() {
	// int local;
	// for(int i=0;i<local;loc/*cursor*/
	public void testForStatement3() throws Exception {
		final String[] expected = { "local" };
		assertCompletionResults(expected);
	}

	//	#define INIT_PTR(PtrName)   (PtrName) = 0;
	//	struct CCApp {
	//	   int pIShell;
	//	};
	//
	//	int main(void) {
	//	   struct CCApp *pThis = 0;
	//	   INIT_PTR(pTh/*cursor*/);
	//	}
	public void testCompletionInMacroArguments1_Bug200208() throws Exception {
		final String[] expected = { "pThis" };
		assertCompletionResults(expected);
	}

	//	#define INIT_PTR(PtrName)   (PtrName) = 0;
	//	#define COPY_PTR(pTarget, pSource)   (pTarget) = (pSource)
	//
	//	struct CCApp {
	//	   int pIShell;
	//	};
	//
	//	int main(void) {
	//	   struct CCApp *pThis = 0;
	//
	//	   INIT_PTR(pThis);
	//     COPY_PTR(pThis->pIShell, pThis->pI/*cursor*/)
	//	}
	public void testCompletionInMacroArguments2_Bug200208() throws Exception {
		final String[] expected = { "pIShell" };
		assertCompletionResults(expected);
	}

	//	enum {enum0, enum1, enum2};
	//	typedef struct {
	//	   int byte1;
	//	   int byte2;
	//	} MYSTRUCT_TYPE;
	//	static const MYSTRUCT_TYPE myArrayOfStructs[] = {{enum/*cursor*/
	public void testCompletionInInitializerList_Bug230389() throws Exception {
		final String[] expected = { "enum0", "enum1", "enum2" };
		assertCompletionResults(expected);
	}

	//  void test() {struct s206450 x; x./*cursor*/
	public void testNestedAnonymousStructs_Bug206450() throws Exception {
		final String[] expected = { "a1", "a2", "u1", "u2", "a4", "b" };
		assertCompletionResults(expected);
	}

	// #define bug204758
	///*include*/
	//  void test() {_f204758/*cursor*/
	public void testTypedefToAnonymous_Bug204758() throws Exception {
		final String[] expected = { "_f204758(_e204758)" };
		assertCompletionResults(expected);
	}

	//	int main(void) {
	//		struct {
	//		    void (*bar)(p1, p2, p3...);
	//		} foo;
	//		foo.bar(/*cursor*/
	public void testClassCastException_Bug517954() throws Exception {
		// Just check that no exception is thrown while invoking completion.
		assertContentAssistResults(fCursorOffset, new String[] {}, DEFAULT_FLAGS | ALLOW_EXTRA_RESULTS, CompareType.ID);
	}
}