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
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
|
/*******************************************************************************
* Copyright (c) 2000, 2004 IBM Corporation and others.
* All rights reserved. This program and the accompanying materials
* are made available under the terms of the Common Public License v1.0
* which accompanies this distribution, and is available at
* http://www.eclipse.org/legal/cpl-v10.html
*
* Contributors:
* IBM Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jface.text.tests.rules;
import junit.framework.TestCase;
import org.eclipse.jface.text.Document;
import org.eclipse.jface.text.IDocument;
import org.eclipse.jface.text.ITypedRegion;
import org.eclipse.jface.text.rules.DefaultPartitioner;
import org.eclipse.jface.text.rules.IPartitionTokenScanner;
import org.eclipse.jface.text.rules.IPredicateRule;
import org.eclipse.jface.text.rules.IToken;
import org.eclipse.jface.text.rules.MultiLineRule;
import org.eclipse.jface.text.rules.RuleBasedPartitionScanner;
import org.eclipse.jface.text.rules.Token;
/**
* @since 3.0
*/
public class DefaultPartitionerTest extends TestCase {
private static final String COMMENT= "comment";
private static final String DEFAULT= IDocument.DEFAULT_CONTENT_TYPE;
private IDocument fDoc;
private DefaultPartitioner fPartitioner;
public void setUp() {
fDoc= new Document();
IPartitionTokenScanner scanner= new RuleBasedPartitionScanner() {
{
IToken comment= new Token(COMMENT);
IPredicateRule[] rules= new IPredicateRule[] { new MultiLineRule("/*", "*/", comment) };
setPredicateRules(rules);
}
};
fPartitioner= new DefaultPartitioner(scanner, new String[] { DEFAULT, COMMENT });
fDoc.setDocumentPartitioner(fPartitioner);
fPartitioner.connect(fDoc);
}
public void testGetPartition() {
fDoc.set("docu ment/* comment */docu ment");
int[] offsets= new int[] { 13, 26 };
assertGetPartition_InterleavingPartitions(offsets);
}
public void testGetPartitionEmptyMiddle() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 13, 26, 26, 39 };
assertGetPartition_InterleavingPartitions(offsets);
}
public void testGetPartitionEmptyStart() {
fDoc.set("/* comment */docu ment");
int[] offsets= new int[] { 0, 13 };
assertGetPartition_InterleavingPartitions(offsets);
}
public void testGetPartitionEmptyEnd() {
fDoc.set("docu ment/* comment */");
int[] offsets= new int[] { 13, 26 };
assertGetPartition_InterleavingPartitions(offsets);
}
public void testGetContentType() {
fDoc.set("docu ment/* comment */docu ment");
int[] offsets= new int[] { 13, 26 };
assertGetContentType_InterleavingPartitions(offsets);
}
public void testGetContentTypeEmptyMiddle() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 13, 26, 26, 39 };
assertGetContentType_InterleavingPartitions(offsets);
}
public void testGetContentTypeEmptyStart() {
fDoc.set("/* comment */docu ment");
int[] offsets= new int[] { 0, 13 };
assertGetContentType_InterleavingPartitions(offsets);
}
public void testGetContentTypeEmptyEnd() {
fDoc.set("docu ment/* comment */");
int[] offsets= new int[] { 13, 26 };
assertGetContentType_InterleavingPartitions(offsets);
}
public void testComputePartitioning() {
fDoc.set("docu ment/* comment */docu ment");
int[] offsets= new int[] { 13, 26 };
assertComputePartitioning_InterleavingPartitions(offsets);
}
public void testComputePartitioningEmptyMiddle() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 13, 26, 26, 39 };
assertComputePartitioning_InterleavingPartitions(offsets);
}
public void testComputePartitioningEmptyStart() {
fDoc.set("/* comment */docu ment");
int[] offsets= new int[] { 0, 13 };
assertComputePartitioning_InterleavingPartitions(offsets);
}
public void testComputePartitioningEmptyEnd() {
fDoc.set("docu ment/* comment */");
int[] offsets= new int[] { 13, 26 };
assertComputePartitioning_InterleavingPartitions(offsets);
}
public void testComputePartitioningSubrangeBeforeBoundaries() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 13, 26, 26 };
assertComputePartitioning_InterleavingPartitions(12, 38, offsets, DEFAULT);
}
public void testComputePartitioningSubrangeOnBoundaries() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 13, 26, 26, 39 };
assertComputePartitioning_InterleavingPartitions(13, 39, offsets, DEFAULT);
}
public void testComputePartitioningSubrangeOnBoundaries2() {
fDoc.set("/* comment *//* comment *//* comment */");
int[] offsets= new int[] { 13, 26 };
assertComputePartitioning_InterleavingPartitions(13, 26, offsets, DEFAULT);
}
public void testComputePartitioningSubrangeAfterBoundaries() {
fDoc.set("docu ment/* comment *//* comment */docu ment");
int[] offsets= new int[] { 26, 26, 39 };
assertComputePartitioning_InterleavingPartitions(14, 40, offsets, COMMENT);
}
public void testComputePartitioningSubrangeInBoundaries1() {
fDoc.set("/* comment */");
int[] offsets= new int[] { };
assertComputePartitioning_InterleavingPartitions(1, 12, offsets, COMMENT);
}
public void testComputePartitioningSubrangeInBoundaries2() {
fDoc.set("docu ment");
int[] offsets= new int[] { };
assertComputePartitioning_InterleavingPartitions(1, 12, offsets, DEFAULT);
}
private void assertComputePartitioning_InterleavingPartitions(int[] offsets) {
assertComputePartitioning_InterleavingPartitions(0, fDoc.getLength(), offsets, DEFAULT);
}
private void assertComputePartitioning_InterleavingPartitions(int startOffset, int endOffset, int[] offsets, String startType) {
ITypedRegion[] regions= fPartitioner.computePartitioning(startOffset, endOffset - startOffset);
String type= startType;
int previousOffset= startOffset;
int j= 0;
for (int i= 0; i <= offsets.length; i++) {
int currentOffset= (i == offsets.length) ? endOffset : offsets[i];
if (currentOffset - previousOffset != 0) { // don't do empty partitions
ITypedRegion region= regions[j++];
assertTypedRegion(region, previousOffset, currentOffset, type);
}
// advance
if (type == DEFAULT)
type= COMMENT;
else
type= DEFAULT;
previousOffset= currentOffset;
}
}
private void assertGetContentType_InterleavingPartitions(int[] offsets) {
String type= DEFAULT;
int previousOffset= 0;
for (int i= 0; i <= offsets.length; i++) {
int offset= (i == offsets.length) ? fDoc.getLength() : offsets[i];
assertEqualPartitionType(previousOffset, offset, type);
// advance
if (type == DEFAULT)
type= COMMENT;
else
type= DEFAULT;
previousOffset= offset;
}
}
private void assertGetPartition_InterleavingPartitions(int[] offsets) {
String type= DEFAULT;
int previousOffset= 0;
for (int i= 0; i <= offsets.length; i++) {
int offset= (i == offsets.length) ? fDoc.getLength() : offsets[i];
assertEqualPartition(previousOffset, offset, type);
// advance
if (type == DEFAULT)
type= COMMENT;
else
type= DEFAULT;
previousOffset= offset;
}
}
private void assertEqualPartition(int offset, int end, String type) {
int from= offset;
int to= end - 1;
for (int i= from; i <= to; i++) {
ITypedRegion region= fPartitioner.getPartition(i);
assertTypedRegion(region, offset, end, type);
}
}
private void assertTypedRegion(ITypedRegion region, int offset, int end, String type) {
assertEquals(offset, region.getOffset());
assertEquals(end - offset, region.getLength());
assertEquals(type, region.getType());
}
private void assertEqualPartitionType(int offset, int end, String type) {
int from= offset;
int to= end - 1;
for (int i= from; i <= to; i++) {
assertEquals(type, fPartitioner.getContentType(i));
}
}
}
|
