1
/*******************************************************************************
2
* Copyright (c) 2006, 2010 Wind River Systems, Inc. and others.
3
* All rights reserved. This program and the accompanying materials
4
* are made available under the terms of the Eclipse Public License v1.0
5
* which accompanies this distribution, and is available at
6
* http://www.eclipse.org/legal/epl-v10.html
9
* Anton Leherbauer (Wind River Systems) - initial API and implementation
10
* Elazar Leibovich (The Open University) - extra folding test
11
*******************************************************************************/
12
package org.eclipse.cdt.ui.tests.text;
14
import java.util.ArrayList;
15
import java.util.Collections;
16
import java.util.Comparator;
17
import java.util.Iterator;
18
import java.util.List;
20
import junit.framework.Test;
21
import junit.framework.TestCase;
22
import junit.framework.TestSuite;
24
import org.eclipse.jface.preference.IPreferenceStore;
25
import org.eclipse.jface.text.BadLocationException;
26
import org.eclipse.jface.text.IDocument;
27
import org.eclipse.jface.text.IRegion;
28
import org.eclipse.jface.text.Position;
29
import org.eclipse.jface.text.source.Annotation;
30
import org.eclipse.jface.text.source.SourceViewer;
31
import org.eclipse.jface.text.source.projection.IProjectionPosition;
32
import org.eclipse.jface.text.source.projection.ProjectionAnnotationModel;
34
import org.eclipse.cdt.core.model.ICProject;
35
import org.eclipse.cdt.core.testplugin.CProjectHelper;
36
import org.eclipse.cdt.ui.CUIPlugin;
37
import org.eclipse.cdt.ui.PreferenceConstants;
38
import org.eclipse.cdt.ui.testplugin.EditorTestHelper;
39
import org.eclipse.cdt.ui.testplugin.ResourceTestHelper;
41
import org.eclipse.cdt.internal.ui.editor.CEditor;
46
public class FoldingTest extends TestCase {
48
private static class ProjectionPosition extends Position implements IProjectionPosition, IRegion {
49
private int fCaptionOffset;
50
ProjectionPosition(int offset, int length, int captionOffset) {
51
super(offset, length);
52
fCaptionOffset= captionOffset;
54
public int computeCaptionOffset(IDocument document) throws BadLocationException {
55
return fCaptionOffset;
57
public IRegion[] computeProjectionRegions(IDocument document) throws BadLocationException {
58
return new IRegion[] { this };
62
private static final String LINKED_FOLDER= "resources/folding";
63
private static final String PROJECT= "FoldingTest";
65
private ICProject fCProject;
66
private final String fTestFilename= "/FoldingTest/src/FoldingTest.cpp";
68
private static CEditor fEditor;
70
private static SourceViewer fSourceViewer;
72
public static Test suite() {
73
return new TestSuite(FoldingTest.class);
76
public FoldingTest(String name) {
81
protected void setUp() throws Exception {
83
fCProject= EditorTestHelper.createCProject(PROJECT, LINKED_FOLDER);
85
IPreferenceStore store= CUIPlugin.getDefault().getPreferenceStore();
86
store.setValue(PreferenceConstants.EDITOR_FOLDING_ENABLED, true);
87
store.setValue(PreferenceConstants.EDITOR_FOLDING_STATEMENTS, true);
88
store.setValue(PreferenceConstants.EDITOR_FOLDING_PREPROCESSOR_BRANCHES_ENABLED, true);
89
store.setValue(PreferenceConstants.EDITOR_FOLDING_INACTIVE_CODE, false);
90
store.setValue(PreferenceConstants.EDITOR_FOLDING_HEADERS, false);
92
fEditor= (CEditor) EditorTestHelper.openInEditor(ResourceTestHelper.findFile(fTestFilename), true);
93
fSourceViewer= EditorTestHelper.getSourceViewer(fEditor);
94
assertTrue(EditorTestHelper.joinReconciler(fSourceViewer, 0, 10000, 300));
98
protected void tearDown () throws Exception {
99
EditorTestHelper.closeEditor(fEditor);
101
if (fCProject != null)
102
CProjectHelper.delete(fCProject);
104
IPreferenceStore store= CUIPlugin.getDefault().getPreferenceStore();
105
store.setToDefault(PreferenceConstants.EDITOR_FOLDING_ENABLED);
106
store.setToDefault(PreferenceConstants.EDITOR_FOLDING_STATEMENTS);
107
store.setToDefault(PreferenceConstants.EDITOR_FOLDING_PREPROCESSOR_BRANCHES_ENABLED);
108
store.setToDefault(PreferenceConstants.EDITOR_FOLDING_INACTIVE_CODE);
109
store.setToDefault(PreferenceConstants.EDITOR_FOLDING_HEADERS);
114
protected void assertEqualPositions(Position[] expected, Position[] actual) throws BadLocationException {
115
assertEquals(expected.length, actual.length);
116
IDocument document= fSourceViewer.getDocument();
117
for (int i= 0, n= expected.length; i < n; i++) {
118
final Position exp = expected[i];
119
int expectedStartLine= document.getLineOfOffset(exp.getOffset());
120
int expectedEndLine= document.getLineOfOffset(exp.getOffset()+exp.getLength());
121
final Position act = actual[i];
122
int actualStartLine= document.getLineOfOffset(act.getOffset());
123
int actualEndLine= document.getLineOfOffset(act.getOffset()+exp.getLength());
124
assertEquals(exp.isDeleted(), act.isDeleted());
125
assertEquals(expectedStartLine, actualStartLine);
126
assertEquals(expectedEndLine, actualEndLine);
127
if (exp instanceof IProjectionPosition) {
128
int expectedCaptionOffset= ((IProjectionPosition)exp).computeCaptionOffset(document);
129
int expectedCaptionLine= document.getLineOfOffset(exp.getOffset() + expectedCaptionOffset);
130
int actualCaptionLine= actualStartLine;
131
if (act instanceof IProjectionPosition) {
132
int actualCaptionOffset= ((IProjectionPosition)act).computeCaptionOffset(document);
133
actualCaptionLine= document.getLineOfOffset(exp.getOffset() + actualCaptionOffset);
135
assertEquals(expectedCaptionLine, actualCaptionLine);
140
protected Position createPosition(int startLine, int endLine) throws BadLocationException {
141
IDocument document= fSourceViewer.getDocument();
142
int startOffset= document.getLineOffset(startLine);
143
int endOffset= document.getLineOffset(endLine) + document.getLineLength(endLine);
144
return new Position(startOffset, endOffset - startOffset);
147
protected Position createPosition(int startLine, int endLine, int captionLine) throws BadLocationException {
148
IDocument document= fSourceViewer.getDocument();
149
int startOffset= document.getLineOffset(startLine);
150
int endOffset= document.getLineOffset(endLine) + document.getLineLength(endLine);
151
int captionOffset= document.getLineOffset(captionLine);
152
return new ProjectionPosition(startOffset, endOffset - startOffset, captionOffset - startOffset);
155
String toString(Position[] positions) throws BadLocationException {
156
StringBuffer buf= new StringBuffer();
157
IDocument document= fSourceViewer.getDocument();
158
buf.append("Position[] expected= new Position[] {\n");
159
for (int i= 0, n= positions.length; i < n; i++) {
160
Position position= positions[i];
161
int startLine= document.getLineOfOffset(position.getOffset());
162
int endLine= document.getLineOfOffset(position.getOffset()+position.getLength()-1);
163
int captionLine= startLine;
164
if (position instanceof IProjectionPosition) {
165
final int captionOffset = ((IProjectionPosition)position).computeCaptionOffset(document);
166
captionLine= document.getLineOfOffset(position.getOffset() + captionOffset);
168
buf.append("\tcreatePosition(");
169
buf.append(startLine);
172
if (captionLine != startLine) {
174
buf.append(captionLine);
179
return buf.toString();
182
protected Position[] getFoldingPositions() {
183
List<Position> positions= new ArrayList<Position>();
184
ProjectionAnnotationModel model= (ProjectionAnnotationModel)fEditor.getAdapter(ProjectionAnnotationModel.class);
185
assertNotNull(model);
186
for (Iterator<Annotation> iter= model.getAnnotationIterator(); iter.hasNext(); ) {
187
Annotation ann= iter.next();
188
Position pos= model.getPosition(ann);
191
Collections.sort(positions, new Comparator<Position>() {
192
public int compare(Position p0, Position p1) {
193
return p0.offset - p1.offset;
195
return positions.toArray(new Position[positions.size()]);
198
public void testInitialFolding() throws BadLocationException {
199
Position[] actual= getFoldingPositions();
200
Position[] expected= new Position[] {
201
createPosition(0, 2, 1),
202
createPosition(4, 7),
203
createPosition(9, 12),
204
createPosition(10, 12),
205
createPosition(13, 14),
206
createPosition(15, 27),
207
createPosition(16, 26),
208
createPosition(17, 20),
209
createPosition(18, 20),
210
createPosition(21, 25),
211
createPosition(22, 24),
212
createPosition(29, 31, 30),
213
createPosition(34, 35),
214
createPosition(35, 40),
215
createPosition(36, 38),
216
createPosition(42, 46),
217
createPosition(48, 55),
218
createPosition(51, 53),
219
createPosition(57, 59),
220
createPosition(61, 63),
221
createPosition(65, 67),
222
createPosition(70, 104, 71),
223
createPosition(75, 76),
224
createPosition(77, 79),
225
createPosition(80, 82),
226
createPosition(83, 85),
227
createPosition(86, 94),
228
createPosition(87, 89),
229
createPosition(90, 91),
230
createPosition(92, 93),
231
createPosition(95, 97),
232
createPosition(99, 102),
233
createPosition(106, 110),
234
createPosition(113, 117, 115),
235
createPosition(119, 127),
236
createPosition(120, 122),
237
createPosition(123, 126),
238
createPosition(129, 130),
240
assertEquals(toString(expected), toString(actual));
241
assertEqualPositions(expected, actual);
244
public void testToggleFolding_Bug186729() throws BadLocationException {
245
fEditor.getAction("FoldingToggle").run();
246
IPreferenceStore store= CUIPlugin.getDefault().getPreferenceStore();
247
store.setValue(PreferenceConstants.EDITOR_FOLDING_PREPROCESSOR_BRANCHES_ENABLED, false);
248
fEditor.getAction("FoldingToggle").run();
250
Position[] actual= getFoldingPositions();
251
Position[] expected= new Position[] {
252
createPosition(0, 2, 1),
253
createPosition(4, 7),
254
createPosition(29, 31, 30),
255
createPosition(35, 40),
256
createPosition(42, 46),
257
createPosition(48, 55),
258
createPosition(51, 53),
259
createPosition(57, 59),
260
createPosition(61, 63),
261
createPosition(65, 67),
262
createPosition(70, 104, 71),
263
createPosition(75, 76),
264
createPosition(77, 79),
265
createPosition(80, 82),
266
createPosition(83, 85),
267
createPosition(86, 94),
268
createPosition(87, 89),
269
createPosition(90, 91),
270
createPosition(92, 93),
271
createPosition(95, 97),
272
createPosition(99, 102),
273
createPosition(106, 110),
274
createPosition(113, 117, 115),
275
createPosition(119, 127),
276
createPosition(120, 122),
277
createPosition(123, 126),
279
assertEquals(toString(expected), toString(actual));
280
assertEqualPositions(expected, actual);
283
public void testToggleFoldingNoASTRequired() throws BadLocationException {
284
fEditor.getAction("FoldingToggle").run();
285
IPreferenceStore store= CUIPlugin.getDefault().getPreferenceStore();
286
store.setValue(PreferenceConstants.EDITOR_FOLDING_STATEMENTS, false);
287
store.setValue(PreferenceConstants.EDITOR_FOLDING_PREPROCESSOR_BRANCHES_ENABLED, false);
288
fEditor.getAction("FoldingToggle").run();
290
Position[] actual= getFoldingPositions();
291
Position[] expected= new Position[] {
292
createPosition(0, 2, 1),
293
createPosition(4, 7),
294
createPosition(29, 31, 30),
295
createPosition(35, 40),
296
createPosition(42, 46),
297
createPosition(48, 55),
298
createPosition(51, 53),
299
createPosition(57, 59),
300
createPosition(61, 63),
301
createPosition(65, 67),
302
createPosition(70, 104, 71),
303
createPosition(106, 110),
304
createPosition(113, 117, 115),
305
createPosition(119, 127),
307
assertEquals(toString(expected), toString(actual));
308
assertEqualPositions(expected, actual);