1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
|
/**********************************************************************
* Copyright (c) 2002,2003 Rational Software Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v0.5
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v05.html
*
* Contributors:
* IBM Rational Software - Initial API and implementation
***********************************************************************/
package org.eclipse.cdt.core.parser.failedTests;
import java.io.IOException;
import java.io.StringWriter;
import java.io.Writer;
import java.util.Iterator;
import org.eclipse.cdt.core.parser.ParserLanguage;
import org.eclipse.cdt.core.parser.ast.IASTAbstractTypeSpecifierDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTClassSpecifier;
import org.eclipse.cdt.core.parser.ast.IASTFunction;
import org.eclipse.cdt.core.parser.ast.IASTTypedefDeclaration;
import org.eclipse.cdt.core.parser.ast.IASTVariable;
import org.eclipse.cdt.core.parser.tests.BaseASTTest;
/**
* @author jcamelon
*
*/
public class ASTFailedTests extends BaseASTTest
{
public ASTFailedTests(String name)
{
super(name);
}
public void testBug36730() throws Exception
{
assertCodeFailsParse("FUNCTION_MACRO( 1, a )\n int i;");
}
//Here C99-specific section ends
//Here GCC-specific section starts
public void testBug39676() throws Exception
{
assertCodeFailsParse("struct { int e1, e2; } v = { e2: 0 }");
}
public void testBug39677() throws Exception
{
assertCodeFailsParse("B::B() : a(({ 1; })) {}");
}
public void testBug39678() throws Exception
{
assertCodeFailsParse("char *s = L\"a\" \"b\";");
}
public void testBug39679() throws Exception
{
assertCodeFailsParse("Foo blat() return f(4) {}");
}
public void testBug39681() throws Exception
{
Writer code = new StringWriter();
try
{
code.write("double\n");
code.write("foo (double a, double b)\n");
code.write("{\n");
code.write(" double square (double z) { return z * z; }\n");
code.write(" return square (a) + square (b);\n");
code.write("}\n");
}
catch (IOException ioe)
{
}
parse(code.toString());
}
public void testBug39682() throws Exception
{
IASTTypedefDeclaration typedef = (IASTTypedefDeclaration)parse("typedef name = (a+1);").getDeclarations().next();
assertFalse(
"The expected error did not occur.",
typedef.getName().equals( "name" ) );
}
public void testBug39684() throws Exception
{
assertCodeFailsParse("typeof(foo(1)) bar () { return foo(1); }");
}
public void testBug39686() throws Exception
{
Writer code = new StringWriter();
try
{
code.write("__complex__ double x; // complex double\n");
code.write("__complex__ short int a; // complex short int\n");
code.write("x = 2.5fi; // 2.5 imaginary float literal\n");
code.write("a = 3i; // imaginary integer literal\n");
code.write("double v = __real__ x; // real part of expression\n");
code.write(
"double w = __imag__ x; // imaginary part of expression\n");
}
catch (IOException ioe)
{
}
assertCodeFailsParse(code.toString());
}
public void testBug39687() throws Exception
{
assertCodeFailsParse("struct entry tester (int len; char data[len][len], int len) {}");
}
public void testBug39688() throws Exception
{
Writer code = new StringWriter();
try
{
code.write("#define decl(type, vars...) \\\n");
code.write(" type vars ;\n");
code.write("decl(int, x, y)\n");
}
catch (IOException ioe)
{
}
assertCodeFailsParse(code.toString());
}
public void testBug39694() throws Exception
{
IASTVariable variable = (IASTVariable)parse("int ab$cd = 1;").getDeclarations().next();
assertFalse(
"The expected error did not occur.",
variable.equals("ab$cd"));
}
public void testBug39695() throws Exception
{
assertCodeFailsParse("int a = __alignof__ (int);");
}
public void testBug39695A() throws Exception
{
assertCodeFailsParse("int foo asm (\"myfoo\") = 2;");
}
public void testBug39695B() throws Exception
{
assertCodeFailsParse("extern func () asm (\"FUNC\");");
}
public void testBug39695C() throws Exception
{
assertCodeFailsParse("register int *foo asm (\"a5\");");
}
public void testBug39698A() throws Exception
{
assertCodeFailsParse("int c = a <? b;");
}
public void testBug39698B() throws Exception
{
assertCodeFailsParse("int c = a >? b;");
}
public void testBug39701A() throws Exception
{
assertCodeFailsParse("extern template int max (int, int);");
}
public void testBug39701B() throws Exception
{
assertCodeFailsParse("inline template class Foo<int>;");
}
public void testBug39701C() throws Exception
{
assertCodeFailsParse("static template class Foo<int>;");
}
public void testBug39702() throws Exception
{
Writer code = new StringWriter();
try
{
code.write("signature T {\n");
code.write(" int f (int);\n");
code.write(" int f0 () { return f (0); };\n");
code.write("};\n");
}
catch (IOException ioe)
{
}
assertCodeFailsFullParse(code.toString());
}
public void testBug39703() throws Exception
{
Writer code = new StringWriter();
try
{
code.write(
"/* __extension__ enables GNU C mode for the duration of the declaration. */\n");
code.write("__extension__ struct G {\n");
code.write(" struct { char z; };\n");
code.write(" char g;\n");
code.write("};\n");
}
catch (IOException ioe)
{
}
IASTAbstractTypeSpecifierDeclaration abs = (IASTAbstractTypeSpecifierDeclaration)assertSoleDeclaration(code.toString());
assertEquals( ((IASTClassSpecifier)abs.getTypeSpecifier()).getName(), "G" );
}
public void testBug39704A() throws Exception
{
assertCodeFailsParse("__declspec (dllimport) int foo;");
}
public void testBug39704B() throws Exception
{
try
{
IASTVariable d = (IASTVariable)assertSoleDeclaration("extern int (* import) (void) __attribute__((dllimport));");
assertEquals( d.getName(), "__attribute__"); // false assertion
}
catch( ClassCastException cce )
{
failedAsExpected();
}
}
public void testBug39704C() throws Exception
{
try
{
IASTFunction f = (IASTFunction)assertSoleDeclaration("int func2 (void) __attribute__((dllexport));");
assertNotReached();
assertEquals( f.getName(), "func2");
} catch( ClassCastException cce )
{
}
}
public void testBug39704D() throws Exception
{
assertCodeFailsParse("__declspec(dllexport) int func1 (int a) {}");
}
public void testBug39705() throws Exception
{
assertCodeFailsParse("#ident \"@(#)filename.c 1.3 90/02/12\"");
}
public void testBug40422() throws Exception {
// Parse and get the translaton unit
parse("int A::* x = 0;").getDeclarations().next();
}
}
|
