svn-gvsig-desktop / branches / v2_0_0_prep / libraries / libFMap_dal / src-test / org / gvsig / fmap / dal / feature / BaseTestFeatureStore.java @ 26252
History | View | Annotate | Download (21.5 KB)
1 | 26040 | jmvivo | /* gvSIG. Geographic Information System of the Valencian Government
|
---|---|---|---|
2 | *
|
||
3 | * Copyright (C) 2007-2008 Infrastructures and Transports Department
|
||
4 | * of the Valencian Government (CIT)
|
||
5 | *
|
||
6 | * This program is free software; you can redistribute it and/or
|
||
7 | * modify it under the terms of the GNU General Public License
|
||
8 | * as published by the Free Software Foundation; either version 2
|
||
9 | * of the License, or (at your option) any later version.
|
||
10 | *
|
||
11 | * This program is distributed in the hope that it will be useful,
|
||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
14 | * GNU General Public License for more details.
|
||
15 | *
|
||
16 | * You should have received a copy of the GNU General Public License
|
||
17 | * along with this program; if not, write to the Free Software
|
||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
||
19 | * MA 02110-1301, USA.
|
||
20 | *
|
||
21 | */
|
||
22 | |||
23 | /*
|
||
24 | * AUTHORS (In addition to CIT):
|
||
25 | * 2009 IVER T.I. S.A. {{Task}}
|
||
26 | */
|
||
27 | |||
28 | /**
|
||
29 | *
|
||
30 | */
|
||
31 | package org.gvsig.fmap.dal.feature; |
||
32 | |||
33 | import java.util.Iterator; |
||
34 | 26042 | jmvivo | import java.util.Random; |
35 | 26040 | jmvivo | |
36 | import junit.framework.TestCase; |
||
37 | |||
38 | import org.gvsig.fmap.dal.DALLibrary; |
||
39 | import org.gvsig.fmap.dal.DALLocator; |
||
40 | import org.gvsig.fmap.dal.DataManager; |
||
41 | import org.gvsig.fmap.dal.DataServerExplorer; |
||
42 | import org.gvsig.fmap.dal.DataStoreParameters; |
||
43 | import org.gvsig.fmap.dal.DataTypes; |
||
44 | import org.gvsig.fmap.dal.exception.DataException; |
||
45 | import org.gvsig.fmap.geom.Geometry; |
||
46 | import org.gvsig.tools.ToolsLibrary; |
||
47 | import org.gvsig.tools.ToolsLocator; |
||
48 | import org.gvsig.tools.dynobject.DynClass; |
||
49 | import org.gvsig.tools.dynobject.DynField; |
||
50 | import org.gvsig.tools.dynobject.DynObject; |
||
51 | 26061 | jmvivo | import org.gvsig.tools.evaluator.Evaluator; |
52 | import org.gvsig.tools.evaluator.EvaluatorData; |
||
53 | import org.gvsig.tools.evaluator.EvaluatorException; |
||
54 | import org.gvsig.tools.evaluator.EvaluatorFieldValue; |
||
55 | 26040 | jmvivo | import org.gvsig.tools.persistence.PersistenceException; |
56 | import org.gvsig.tools.persistence.PersistentState; |
||
57 | |||
58 | /**
|
||
59 | * @author jmvivo
|
||
60 | *
|
||
61 | */
|
||
62 | public abstract class BaseTestFeatureStore extends TestCase { |
||
63 | |||
64 | protected static DataManager dataManager = null; |
||
65 | protected boolean baseTestInitialized = false; |
||
66 | 26252 | jmvivo | private static Random rnd; |
67 | 26040 | jmvivo | |
68 | 26062 | jmvivo | |
69 | public abstract boolean hasExplorer(); |
||
70 | |||
71 | |||
72 | public abstract DataStoreParameters getDefaultDataStoreParameters() |
||
73 | throws DataException;
|
||
74 | |||
75 | /*
|
||
76 | * (non-Javadoc)
|
||
77 | 26066 | jmvivo | *
|
78 | 26040 | jmvivo | * @see junit.framework.TestCase#setUp()
|
79 | */
|
||
80 | protected void setUp() throws Exception { |
||
81 | super.setUp();
|
||
82 | |||
83 | if (baseTestInitialized) {
|
||
84 | return;
|
||
85 | } |
||
86 | ToolsLibrary tools = new ToolsLibrary();
|
||
87 | tools.initialize(); |
||
88 | tools.postInitialize(); |
||
89 | |||
90 | DALLibrary lib = new DALLibrary();
|
||
91 | lib.initialize(); |
||
92 | lib.postInitialize(); |
||
93 | |||
94 | dataManager = DALLocator.getDataManager(); |
||
95 | baseTestInitialized = true;
|
||
96 | |||
97 | } |
||
98 | |||
99 | 26062 | jmvivo | |
100 | |||
101 | //=================================================
|
||
102 | |||
103 | 26066 | jmvivo | |
104 | public void printFeature(Feature feature, int maxColSize) { |
||
105 | 26252 | jmvivo | printFeature(feature, true, maxColSize);
|
106 | 26066 | jmvivo | } |
107 | |||
108 | |||
109 | public void printFeature(Feature feature, boolean showColName,int maxColSize) { |
||
110 | FeatureType fType = feature.getType(); |
||
111 | if (showColName){
|
||
112 | this.printFeatureTypeColNames(feature.getType(), maxColSize);
|
||
113 | } |
||
114 | StringBuilder row = new StringBuilder(); |
||
115 | Iterator iter = fType.iterator();
|
||
116 | FeatureAttributeDescriptor attr; |
||
117 | |||
118 | while (iter.hasNext()) {
|
||
119 | attr = (FeatureAttributeDescriptor) iter.next(); |
||
120 | row.append(truncateOrFillString(feature.get(attr.getName()), |
||
121 | maxColSize + 1, ' ')); |
||
122 | } |
||
123 | System.out.println(row.toString());
|
||
124 | } |
||
125 | |||
126 | public String truncateOrFillString(Object str, int max, char fillWith) { |
||
127 | if (str == null) { |
||
128 | return truncateOrFillString("{null}", max, fillWith); |
||
129 | } |
||
130 | return truncateOrFillString(str.toString(), max, fillWith);
|
||
131 | } |
||
132 | |||
133 | public String truncateOrFillString(String str, int max, char fillWith) { |
||
134 | if (str.length() > max) {
|
||
135 | 26252 | jmvivo | return str.substring(0, max - 1) + " "; |
136 | 26066 | jmvivo | } else {
|
137 | StringBuilder strB = new StringBuilder(str); |
||
138 | while (strB.length() < max) {
|
||
139 | strB.append(fillWith); |
||
140 | } |
||
141 | return strB.toString();
|
||
142 | } |
||
143 | |||
144 | } |
||
145 | |||
146 | public void printFeatureTypeColNames(FeatureType fType, int maxColSize) { |
||
147 | Iterator iter = fType.iterator();
|
||
148 | FeatureAttributeDescriptor attr; |
||
149 | StringBuilder colNames = new StringBuilder(); |
||
150 | StringBuilder typeNames = new StringBuilder(); |
||
151 | StringBuilder sep = new StringBuilder(); |
||
152 | if (maxColSize < 1){ |
||
153 | maxColSize = 15;
|
||
154 | } |
||
155 | while (iter.hasNext()) {
|
||
156 | attr = (FeatureAttributeDescriptor) iter.next(); |
||
157 | colNames.append(truncateOrFillString(attr.getName(), maxColSize + 1, ' ')); |
||
158 | typeNames.append(truncateOrFillString("(" + attr.getDataTypeName() + ")", |
||
159 | maxColSize + 1, ' ')); |
||
160 | sep.append(truncateOrFillString("", maxColSize, '=')); |
||
161 | sep.append(' ');
|
||
162 | } |
||
163 | |||
164 | System.out.println(""); |
||
165 | System.out.println(""); |
||
166 | System.out.println(colNames.toString());
|
||
167 | System.out.println(typeNames.toString());
|
||
168 | System.out.println(sep.toString());
|
||
169 | } |
||
170 | |||
171 | 26062 | jmvivo | protected FeatureAttributeDescriptor getFirstAttributeOfType(
|
172 | FeatureType ftype, int dataType) {
|
||
173 | return getFirstAttributeOfType(ftype, new int[] { dataType }); |
||
174 | } |
||
175 | |||
176 | protected FeatureAttributeDescriptor getFirstAttributeOfType(
|
||
177 | FeatureType ftype, int[] dataTypes) { |
||
178 | FeatureAttributeDescriptor attr; |
||
179 | Iterator iter = ftype.iterator();
|
||
180 | int i;
|
||
181 | while (iter.hasNext()) {
|
||
182 | attr = (FeatureAttributeDescriptor) iter.next(); |
||
183 | for (i = 0; i < dataTypes.length; i++) { |
||
184 | if (attr.getDataType() == dataTypes[i]) {
|
||
185 | return attr;
|
||
186 | } |
||
187 | } |
||
188 | } |
||
189 | return null; |
||
190 | } |
||
191 | |||
192 | protected boolean compareDynObject(DynObject obj1, DynObject obj2) { |
||
193 | DynClass dynClass = obj1.getDynClass(); |
||
194 | if (!dynClass.getName().equals(obj2.getDynClass().getName())) {
|
||
195 | return false; |
||
196 | } |
||
197 | |||
198 | DynField[] fields = dynClass.getDeclaredDynFields();
|
||
199 | String fieldName;
|
||
200 | Object v1, v2;
|
||
201 | for (int i = 0; i < fields.length; i++) { |
||
202 | fieldName = fields[i].getName(); |
||
203 | v1 = obj1.getDynValue(fieldName); |
||
204 | v2 = obj2.getDynValue(fieldName); |
||
205 | if (v1 == v2) {
|
||
206 | continue;
|
||
207 | } else if (v1 != null) { |
||
208 | if (!v1.equals(v2)) {
|
||
209 | return false; |
||
210 | } |
||
211 | } |
||
212 | } |
||
213 | |||
214 | return true; |
||
215 | } |
||
216 | |||
217 | protected boolean compareStores(FeatureStore store1, FeatureStore store2) |
||
218 | throws DataException {
|
||
219 | if (store1.getParameters().getClass() != store2.getParameters()
|
||
220 | .getClass()) { |
||
221 | return false; |
||
222 | } |
||
223 | if (!compareDynObject(store1.getParameters(), store2.getParameters())) {
|
||
224 | return false; |
||
225 | } |
||
226 | if (!store1.getName().equals(store2.getName())) {
|
||
227 | return false; |
||
228 | } |
||
229 | if (((FeatureSelection) store1.getSelection()).getSize() != ((FeatureSelection) store2
|
||
230 | .getSelection()).getSize()) { |
||
231 | return false; |
||
232 | } |
||
233 | Iterator iter1 = ((FeatureSelection) store1.getSelection())
|
||
234 | .fastIterator(); |
||
235 | Iterator iter2 = ((FeatureSelection) store2.getSelection())
|
||
236 | .fastIterator(); |
||
237 | if (!compareFeatureIterators(iter1, iter2)) {
|
||
238 | return false; |
||
239 | } |
||
240 | if (store1.getFeatureTypes().size() != store2.getFeatureTypes().size()) {
|
||
241 | return false; |
||
242 | } |
||
243 | iter1 = store1.getFeatureTypes().iterator(); |
||
244 | iter2 = store2.getFeatureTypes().iterator(); |
||
245 | while (iter1.hasNext()) {
|
||
246 | if (!compareTypes((FeatureType) iter1.next(), (FeatureType) iter2
|
||
247 | .next())) { |
||
248 | return false; |
||
249 | } |
||
250 | } |
||
251 | if (!compareTypes(store1.getDefaultFeatureType(), store2
|
||
252 | .getDefaultFeatureType())) { |
||
253 | return false; |
||
254 | } |
||
255 | |||
256 | if (store1.getLocks() != null) { |
||
257 | if (store1.getLocks().getLocksCount() != store2.getLocks()
|
||
258 | .getLocksCount()) { |
||
259 | return false; |
||
260 | } |
||
261 | if (!compareFeatureIterators(store1.getLocks().getLocks(), store2
|
||
262 | .getLocks().getLocks())) { |
||
263 | return false; |
||
264 | } |
||
265 | |||
266 | } else if (store2.getLocks() != null) { |
||
267 | return false; |
||
268 | } |
||
269 | |||
270 | return true; |
||
271 | } |
||
272 | |||
273 | protected boolean compareFeatureIterators(Iterator iter1, Iterator iter2) { |
||
274 | Feature feature; |
||
275 | Feature ffeature; |
||
276 | while (iter1.hasNext()) {
|
||
277 | feature = (Feature) iter1.next(); |
||
278 | ffeature = (Feature) iter2.next(); |
||
279 | if (!this.compareFeatures(feature, ffeature)) { |
||
280 | return false; |
||
281 | } |
||
282 | } |
||
283 | |||
284 | return !iter2.hasNext();
|
||
285 | |||
286 | } |
||
287 | |||
288 | protected boolean compareFeatureIterators(Iterator iter1, Iterator iter2, |
||
289 | String[] attrNames) { |
||
290 | Feature feature; |
||
291 | Feature ffeature; |
||
292 | while (iter1.hasNext()) {
|
||
293 | feature = (Feature) iter1.next(); |
||
294 | ffeature = (Feature) iter2.next(); |
||
295 | if (!this.compareFeatures(feature, ffeature, attrNames)) { |
||
296 | return false; |
||
297 | } |
||
298 | } |
||
299 | |||
300 | return !iter2.hasNext();
|
||
301 | |||
302 | } |
||
303 | |||
304 | protected boolean compareTypes(FeatureType ft1, FeatureType ft2) { |
||
305 | if (ft1.size() != ft2.size()) {
|
||
306 | return false; |
||
307 | } |
||
308 | if (ft1.getDefaultGeometryAttributeIndex() != ft2
|
||
309 | .getDefaultGeometryAttributeIndex()) { |
||
310 | return false; |
||
311 | } |
||
312 | if (ft1.getDefaultGeometryAttributeIndex() > -1) { |
||
313 | if (ft1.getDefaultSRS() != null) { |
||
314 | if (!ft1.getDefaultSRS().equals(ft2.getDefaultSRS())) {
|
||
315 | return false; |
||
316 | } |
||
317 | |||
318 | } else {
|
||
319 | if (ft2.getDefaultSRS() != null) { |
||
320 | return false; |
||
321 | } |
||
322 | } |
||
323 | } |
||
324 | |||
325 | if (ft1.getDefaultGeometryAttributeName() != null) { |
||
326 | if (!ft1.getDefaultGeometryAttributeName().equals(
|
||
327 | ft2.getDefaultGeometryAttributeName())) { |
||
328 | return false; |
||
329 | } |
||
330 | } else {
|
||
331 | if (ft2.getDefaultGeometryAttributeName() != null) { |
||
332 | return false; |
||
333 | } |
||
334 | } |
||
335 | |||
336 | FeatureAttributeDescriptor attr1, attr2; |
||
337 | for (int i = 0; i < ft1.size(); i++) { |
||
338 | attr1 = ft1.getAttributeDescriptor(i); |
||
339 | attr2 = ft2.getAttributeDescriptor(i); |
||
340 | |||
341 | if (!compareAttributes(attr1, attr2)) {
|
||
342 | return false; |
||
343 | } |
||
344 | |||
345 | } |
||
346 | return true; |
||
347 | |||
348 | } |
||
349 | |||
350 | protected boolean compareAttributes(FeatureAttributeDescriptor attr1, |
||
351 | FeatureAttributeDescriptor attr2) { |
||
352 | if (attr1 == null || attr2 == null) { |
||
353 | return false; |
||
354 | } |
||
355 | if (!attr1.getName().equals(attr2.getName())) {
|
||
356 | return false; |
||
357 | } |
||
358 | |||
359 | if (attr1.getDataType() != attr2.getDataType()) {
|
||
360 | return false; |
||
361 | } |
||
362 | |||
363 | if (attr1.getSize() != attr2.getSize()) {
|
||
364 | return false; |
||
365 | } |
||
366 | |||
367 | if (attr1.getPrecision() != attr2.getPrecision()) {
|
||
368 | return false; |
||
369 | } |
||
370 | return true; |
||
371 | } |
||
372 | |||
373 | protected boolean compareFeatures(Feature f1, Feature f2, |
||
374 | String[] attrsNames) { |
||
375 | FeatureAttributeDescriptor attr1; |
||
376 | FeatureAttributeDescriptor attr2; |
||
377 | Object v1, v2;
|
||
378 | for (int i = 0; i < attrsNames.length; i++) { |
||
379 | attr1 = f1.getType().getAttributeDescriptor(attrsNames[i]); |
||
380 | attr2 = f2.getType().getAttributeDescriptor(attrsNames[i]); |
||
381 | if (attr1 != attr2) {
|
||
382 | if (!compareAttributes(attr1, attr1)) {
|
||
383 | return false; |
||
384 | } |
||
385 | } |
||
386 | v1 = f1.get(attr1.getName()); |
||
387 | v2 = f2.get(attr2.getName()); |
||
388 | if (!compareFeatureValue(v1, v2, attr1)) {
|
||
389 | return false; |
||
390 | } |
||
391 | } |
||
392 | |||
393 | return true; |
||
394 | } |
||
395 | |||
396 | protected boolean compareFeatures(Feature f1, Feature f2) { |
||
397 | if (!compareTypes(f1.getType(), f2.getType())) {
|
||
398 | System.out.println("compareFeatures() type !="); |
||
399 | return false; |
||
400 | } |
||
401 | Iterator iter = f1.getType().iterator();
|
||
402 | FeatureAttributeDescriptor attr; |
||
403 | Object v1, v2;
|
||
404 | while (iter.hasNext()) {
|
||
405 | attr = (FeatureAttributeDescriptor) iter.next(); |
||
406 | v1 = f1.get(attr.getName()); |
||
407 | v2 = f2.get(attr.getName()); |
||
408 | if (!compareFeatureValue(v1, v2, attr)) {
|
||
409 | return false; |
||
410 | } |
||
411 | } |
||
412 | |||
413 | return true; |
||
414 | |||
415 | } |
||
416 | |||
417 | protected boolean compareFeatureValue(Object v1, Object v2, |
||
418 | FeatureAttributeDescriptor attr) { |
||
419 | |||
420 | if (v1 == v2) {
|
||
421 | return true; |
||
422 | } else if (v1 == null) { |
||
423 | return false; |
||
424 | } |
||
425 | switch (attr.getDataType()) {
|
||
426 | case DataTypes.FEATURE:
|
||
427 | return compareFeatures((Feature) v1, (Feature) v2);
|
||
428 | |||
429 | case DataTypes.GEOMETRY:
|
||
430 | Geometry geom1 = (Geometry) v1; |
||
431 | Geometry geom2 = (Geometry) v2; |
||
432 | return geom1.equals(geom2);
|
||
433 | case DataTypes.DOUBLE:
|
||
434 | double diff = ((Double) v1).doubleValue() |
||
435 | - ((Double) v1).doubleValue();
|
||
436 | return Math.abs(diff) < 0.000001; |
||
437 | |||
438 | default:
|
||
439 | return v1.equals(v2);
|
||
440 | } |
||
441 | |||
442 | } |
||
443 | |||
444 | |||
445 | //------------------------------------------------
|
||
446 | |||
447 | 26040 | jmvivo | public void testSimpleIteration(FeatureStore store) { |
448 | this.testSimpleIteration(store, null); |
||
449 | } |
||
450 | |||
451 | 26252 | jmvivo | protected String[] getRandomAttibuteList(FeatureType fType) { |
452 | String[] attrNames = new String[fType.size()]; |
||
453 | Iterator iter = fType.iterator();
|
||
454 | int i = 0; |
||
455 | while (iter.hasNext()) {
|
||
456 | attrNames[i] = ((FeatureAttributeDescriptor) iter.next()).getName(); |
||
457 | i++; |
||
458 | } |
||
459 | return this.getRandomAttibuteList(attrNames); |
||
460 | } |
||
461 | |||
462 | protected Random getRandom(){ |
||
463 | if (rnd == null){ |
||
464 | rnd = new Random(); |
||
465 | rnd.setSeed(System.currentTimeMillis());
|
||
466 | } |
||
467 | return rnd;
|
||
468 | } |
||
469 | |||
470 | protected String[] getRandomAttibuteList(String[] attrNames) { |
||
471 | int nAtributes = getRandom().nextInt(attrNames.length + (attrNames.length /2))+1; |
||
472 | String[] res = new String[nAtributes]; |
||
473 | for (int i = 0; i < nAtributes; i++) { |
||
474 | res[i] = attrNames[getRandom().nextInt(attrNames.length)]; |
||
475 | } |
||
476 | return res;
|
||
477 | } |
||
478 | |||
479 | 26061 | jmvivo | public void testIterationFastAndStandart(FeatureStore store) |
480 | throws DataException {
|
||
481 | 26040 | jmvivo | this.testIterationFastAndStandart(store, null); |
482 | 26061 | jmvivo | |
483 | 26252 | jmvivo | FeatureQuery query = store.createFeatureQuery(); |
484 | // Random Attribute list
|
||
485 | query.setAttributeNames(getRandomAttibuteList(store |
||
486 | .getDefaultFeatureType())); |
||
487 | this.testIterationFastAndStandart(store, query);
|
||
488 | |||
489 | 26061 | jmvivo | // Sorted
|
490 | FeatureAttributeDescriptor attr = getFirstAttributeOfType(store |
||
491 | .getDefaultFeatureType(), new int[] { DataTypes.INT, |
||
492 | DataTypes.LONG, DataTypes.STRING }); |
||
493 | 26252 | jmvivo | { |
494 | // asure that attr is in query attributes
|
||
495 | boolean attrFound = false; |
||
496 | String[] curAttrs = query.getAttributeNames(); |
||
497 | for (int i = 0; i < curAttrs.length; i++) { |
||
498 | if (curAttrs[i].equals(attr.getName())) {
|
||
499 | attrFound = true;
|
||
500 | break;
|
||
501 | 26061 | jmvivo | |
502 | 26252 | jmvivo | } |
503 | } |
||
504 | if (!attrFound) {
|
||
505 | String[] newAttrs = new String[curAttrs.length + 1]; |
||
506 | for (int i = 0; i < curAttrs.length; i++) { |
||
507 | newAttrs[i] = curAttrs[i]; |
||
508 | } |
||
509 | newAttrs[curAttrs.length] = attr.getName(); |
||
510 | query.setAttributeNames(newAttrs); |
||
511 | } |
||
512 | } |
||
513 | |||
514 | |||
515 | 26061 | jmvivo | query.getOrder().add(attr.getName(), true);
|
516 | this.testIterationFastAndStandart(store, query);
|
||
517 | |||
518 | // Filter
|
||
519 | query = store.createFeatureQuery(); |
||
520 | |||
521 | query.setFilter(new Evaluator(){
|
||
522 | |||
523 | public Object evaluate(EvaluatorData data) |
||
524 | throws EvaluatorException {
|
||
525 | // TODO Auto-generated method stub
|
||
526 | return Boolean.TRUE; |
||
527 | } |
||
528 | |||
529 | public String getCQL() { |
||
530 | return "true = true"; |
||
531 | } |
||
532 | |||
533 | public String getDescription() { |
||
534 | // TODO Auto-generated method stub
|
||
535 | return null; |
||
536 | } |
||
537 | |||
538 | public EvaluatorFieldValue[] getFieldValues(String name) { |
||
539 | // TODO Auto-generated method stub
|
||
540 | return null; |
||
541 | } |
||
542 | |||
543 | public String getName() { |
||
544 | 26252 | jmvivo | return "AlwaysTrue"; |
545 | 26061 | jmvivo | } |
546 | |||
547 | }); |
||
548 | this.testIterationFastAndStandart(store, query);
|
||
549 | |||
550 | // Filter + Sorted
|
||
551 | query.getOrder().add(attr.getName(), true);
|
||
552 | this.testIterationFastAndStandart(store, query);
|
||
553 | 26040 | jmvivo | } |
554 | |||
555 | public void testSimpleIteration(FeatureStore store, FeatureQuery query) { |
||
556 | FeatureSet set; |
||
557 | try {
|
||
558 | |||
559 | if (query == null) { |
||
560 | query = store.createFeatureQuery(); |
||
561 | } |
||
562 | set = store.getFeatureSet(query); |
||
563 | FeatureType type = set.getDefaultFeatureType(); |
||
564 | |||
565 | Iterator it = set.iterator();
|
||
566 | Iterator ftIt;
|
||
567 | FeatureAttributeDescriptor desc; |
||
568 | |||
569 | Feature feature; |
||
570 | 26066 | jmvivo | printFeatureTypeColNames(type, 15);
|
571 | 26040 | jmvivo | while (it.hasNext()) {
|
572 | |||
573 | feature = (Feature) it.next(); |
||
574 | 26066 | jmvivo | printFeature(feature, false, 15); |
575 | 26040 | jmvivo | } |
576 | |||
577 | set.dispose(); |
||
578 | |||
579 | } catch (DataException e3) {
|
||
580 | e3.printStackTrace(); |
||
581 | fail(); |
||
582 | return;
|
||
583 | } |
||
584 | |||
585 | } |
||
586 | |||
587 | public void testIterationFastAndStandart(FeatureStore store, |
||
588 | FeatureQuery query) { |
||
589 | FeatureSet set; |
||
590 | try {
|
||
591 | |||
592 | if (query == null) { |
||
593 | query = store.createFeatureQuery(); |
||
594 | } |
||
595 | set = store.getFeatureSet(query); |
||
596 | FeatureType type = set.getDefaultFeatureType(); |
||
597 | |||
598 | Iterator it = set.iterator();
|
||
599 | Iterator fit = set.fastIterator();
|
||
600 | |||
601 | assertTrue(this.compareFeatureIterators(it, fit));
|
||
602 | 26061 | jmvivo | |
603 | 26040 | jmvivo | set.dispose(); |
604 | |||
605 | } catch (DataException e3) {
|
||
606 | e3.printStackTrace(); |
||
607 | fail(); |
||
608 | return;
|
||
609 | } |
||
610 | |||
611 | } |
||
612 | |||
613 | public void testSimpleIteration(DataStoreParameters parameters) { |
||
614 | FeatureStore store = null;
|
||
615 | try {
|
||
616 | store = (FeatureStore) dataManager.createStore(parameters); |
||
617 | |||
618 | this.testSimpleIteration(store);
|
||
619 | |||
620 | store.dispose(); |
||
621 | |||
622 | } catch (DataException e3) {
|
||
623 | e3.printStackTrace(); |
||
624 | fail(); |
||
625 | return;
|
||
626 | } |
||
627 | } |
||
628 | |||
629 | public void testIterationFastAndStandart(DataStoreParameters parameters) { |
||
630 | FeatureStore store = null;
|
||
631 | try {
|
||
632 | store = (FeatureStore) dataManager.createStore(parameters); |
||
633 | |||
634 | this.testIterationFastAndStandart(store);
|
||
635 | |||
636 | store.dispose(); |
||
637 | |||
638 | } catch (DataException e3) {
|
||
639 | e3.printStackTrace(); |
||
640 | fail(); |
||
641 | return;
|
||
642 | } |
||
643 | } |
||
644 | |||
645 | /**
|
||
646 | 26066 | jmvivo | *
|
647 | 26040 | jmvivo | * @param count
|
648 | * if (< 0) list.size() >= 1 else list.size() == count
|
||
649 | */
|
||
650 | public void testExplorerList(int count) { |
||
651 | FeatureStore store = null;
|
||
652 | try {
|
||
653 | store = (FeatureStore) dataManager.createStore(this
|
||
654 | .getDefaultDataStoreParameters()); |
||
655 | } catch (Exception e) { |
||
656 | e.printStackTrace(); |
||
657 | fail(); |
||
658 | return;
|
||
659 | } |
||
660 | |||
661 | DataServerExplorer explorer; |
||
662 | try {
|
||
663 | explorer = store.getExplorer(); |
||
664 | } catch (DataException e) {
|
||
665 | e.printStackTrace(); |
||
666 | fail(); |
||
667 | return;
|
||
668 | } |
||
669 | |||
670 | if (count < 0) { |
||
671 | try {
|
||
672 | assertTrue(explorer.list().size() >= 1);
|
||
673 | } catch (DataException e) {
|
||
674 | e.printStackTrace(); |
||
675 | fail(); |
||
676 | return;
|
||
677 | } |
||
678 | |||
679 | } else {
|
||
680 | try {
|
||
681 | assertTrue(explorer.list().size() == count); |
||
682 | } catch (DataException e) {
|
||
683 | e.printStackTrace(); |
||
684 | fail(); |
||
685 | return;
|
||
686 | } |
||
687 | } |
||
688 | |||
689 | try {
|
||
690 | store.dispose(); |
||
691 | } catch (DataException e) {
|
||
692 | e.printStackTrace(); |
||
693 | fail(); |
||
694 | return;
|
||
695 | } |
||
696 | |||
697 | try {
|
||
698 | explorer.dispose(); |
||
699 | } catch (DataException e) {
|
||
700 | e.printStackTrace(); |
||
701 | fail(); |
||
702 | return;
|
||
703 | } |
||
704 | } |
||
705 | |||
706 | 26062 | jmvivo | //=================================================
|
707 | //=================================================
|
||
708 | 26040 | jmvivo | |
709 | |||
710 | 26062 | jmvivo | |
711 | |||
712 | public void testIterationFastAndStandart() { |
||
713 | try {
|
||
714 | this.testIterationFastAndStandart(this |
||
715 | .getDefaultDataStoreParameters()); |
||
716 | } catch (DataException e) {
|
||
717 | e.printStackTrace(); |
||
718 | fail(); |
||
719 | } |
||
720 | } |
||
721 | |||
722 | public void testSimpleIteration() { |
||
723 | try {
|
||
724 | this.testSimpleIteration(this.getDefaultDataStoreParameters()); |
||
725 | } catch (DataException e) {
|
||
726 | e.printStackTrace(); |
||
727 | fail(); |
||
728 | } |
||
729 | } |
||
730 | |||
731 | public void testInitializeStore() { |
||
732 | try {
|
||
733 | FeatureStore store = (FeatureStore) dataManager.createStore(this
|
||
734 | .getDefaultDataStoreParameters()); |
||
735 | store.dispose(); |
||
736 | } catch (DataException e) {
|
||
737 | e.printStackTrace(); |
||
738 | fail(); |
||
739 | } |
||
740 | } |
||
741 | |||
742 | |||
743 | public void testExplorer() { |
||
744 | if (!this.hasExplorer()) { |
||
745 | return;
|
||
746 | } |
||
747 | this.testExplorerList(-1); |
||
748 | |||
749 | } |
||
750 | |||
751 | 26040 | jmvivo | public void testSelection() { |
752 | try {
|
||
753 | DataStoreParameters parameters = this
|
||
754 | .getDefaultDataStoreParameters(); |
||
755 | |||
756 | FeatureStore store = (FeatureStore) dataManager |
||
757 | .createStore(parameters); |
||
758 | FeatureSet set = store.getFeatureSet(); |
||
759 | |||
760 | assertTrue(store.getFeatureSelection().isEmpty()); |
||
761 | store.setSelection(set); |
||
762 | assertFalse(store.getFeatureSelection().isEmpty()); |
||
763 | |||
764 | assertEquals(set.getSize(), store.getFeatureSelection().getSize()); |
||
765 | |||
766 | Iterator iter = set.iterator();
|
||
767 | while (iter.hasNext()) {
|
||
768 | assertTrue(store.getFeatureSelection().isSelected( |
||
769 | (Feature) iter.next())); |
||
770 | } |
||
771 | |||
772 | store.getFeatureSelection().reverse(); |
||
773 | assertTrue(store.getFeatureSelection().isEmpty()); |
||
774 | assertEquals(0, store.getFeatureSelection().getSize());
|
||
775 | store.getFeatureSelection().reverse(); |
||
776 | assertEquals(set.getSize(), store.getFeatureSelection().getSize()); |
||
777 | assertFalse(store.getFeatureSelection().isEmpty()); |
||
778 | |||
779 | set.dispose(); |
||
780 | |||
781 | } catch (DataException e3) {
|
||
782 | e3.printStackTrace(); |
||
783 | fail(); |
||
784 | return;
|
||
785 | } |
||
786 | |||
787 | } |
||
788 | |||
789 | public void testCustomFTypeSet() { |
||
790 | try {
|
||
791 | DataStoreParameters dbfParameters = this
|
||
792 | .getDefaultDataStoreParameters(); |
||
793 | |||
794 | FeatureStore store = (FeatureStore) dataManager |
||
795 | .createStore(dbfParameters); |
||
796 | |||
797 | FeatureSet set, set1; |
||
798 | FeatureQuery query; |
||
799 | Iterator iter, iter1, attrIter;
|
||
800 | Feature feature, feature1; |
||
801 | FeatureAttributeDescriptor attr; |
||
802 | |||
803 | set = store.getFeatureSet(); |
||
804 | attrIter = store.getDefaultFeatureType().iterator(); |
||
805 | |||
806 | 26042 | jmvivo | String[] names; |
807 | 26040 | jmvivo | while (attrIter.hasNext()) {
|
808 | attr = (FeatureAttributeDescriptor) attrIter.next(); |
||
809 | int fieldIndex = attr.getIndex();
|
||
810 | |||
811 | query = store.createFeatureQuery(); |
||
812 | String fieldName = store.getDefaultFeatureType()
|
||
813 | .getAttributeDescriptor(fieldIndex).getName(); |
||
814 | |||
815 | 26042 | jmvivo | names = new String[] { fieldName }; |
816 | query.setAttributeNames(names); |
||
817 | 26040 | jmvivo | set1 = store.getFeatureSet(query); |
818 | |||
819 | 26252 | jmvivo | if (getRandom().nextBoolean()) {
|
820 | iter = set.fastIterator(); |
||
821 | } else {
|
||
822 | iter = set.iterator(); |
||
823 | } |
||
824 | if (getRandom().nextBoolean()) {
|
||
825 | iter1 = set1.fastIterator(); |
||
826 | } else {
|
||
827 | iter1 = set1.iterator(); |
||
828 | } |
||
829 | 26040 | jmvivo | |
830 | 26042 | jmvivo | assertTrue(compareFeatureIterators(iter, iter1, names)); |
831 | 26040 | jmvivo | |
832 | set1.dispose(); |
||
833 | } |
||
834 | 26042 | jmvivo | |
835 | 26252 | jmvivo | int ntimes = getRandom().nextInt(10) + 5; |
836 | 26042 | jmvivo | FeatureType type = store.getDefaultFeatureType(); |
837 | 26252 | jmvivo | query = store.createFeatureQuery(); |
838 | 26042 | jmvivo | for (int i = 0; i < ntimes; i++) { |
839 | 26252 | jmvivo | names = getRandomAttibuteList(type); |
840 | |||
841 | 26042 | jmvivo | query.setAttributeNames(names); |
842 | set1 = store.getFeatureSet(query); |
||
843 | |||
844 | 26252 | jmvivo | if (getRandom().nextBoolean()) {
|
845 | iter = set.fastIterator(); |
||
846 | } else {
|
||
847 | iter = set.iterator(); |
||
848 | } |
||
849 | if (getRandom().nextBoolean()) {
|
||
850 | iter1 = set1.fastIterator(); |
||
851 | } else {
|
||
852 | iter1 = set1.iterator(); |
||
853 | } |
||
854 | 26042 | jmvivo | |
855 | assertTrue(compareFeatureIterators(iter, iter1, names)); |
||
856 | |||
857 | set1.dispose(); |
||
858 | |||
859 | |||
860 | } |
||
861 | |||
862 | |||
863 | |||
864 | 26040 | jmvivo | set.dispose(); |
865 | |||
866 | 26042 | jmvivo | store.dispose(); |
867 | 26040 | jmvivo | } catch (DataException e3) {
|
868 | e3.printStackTrace(); |
||
869 | fail(); |
||
870 | return;
|
||
871 | } |
||
872 | } |
||
873 | |||
874 | public void testPersistence() { |
||
875 | if ((FeatureStore) ToolsLocator.getPersistenceManager() == null) { |
||
876 | fail("Default Persistence Manager not register");
|
||
877 | } |
||
878 | try {
|
||
879 | DataStoreParameters params = this.getDefaultDataStoreParameters();
|
||
880 | |||
881 | |||
882 | FeatureStore store = (FeatureStore) dataManager |
||
883 | .createStore(params); |
||
884 | |||
885 | testSimpleIteration(store); |
||
886 | |||
887 | PersistentState state = store.getState(); |
||
888 | |||
889 | FeatureStore store2 = (FeatureStore) ToolsLocator |
||
890 | .getPersistenceManager().create(state); |
||
891 | |||
892 | testSimpleIteration(store2); |
||
893 | |||
894 | assertTrue(compareStores(store, store2)); |
||
895 | |||
896 | //TODO Compare states
|
||
897 | // XMLEntityState state2 = (XMLEntityState) store.getState();
|
||
898 | //
|
||
899 | // assertEquals(state.getXMLEntity().toString(), state2.getXMLEntity()
|
||
900 | // .toString());
|
||
901 | //
|
||
902 | store.dispose(); |
||
903 | store2.dispose(); |
||
904 | |||
905 | } catch (DataException e3) {
|
||
906 | e3.printStackTrace(); |
||
907 | fail(); |
||
908 | return;
|
||
909 | } catch (PersistenceException e) {
|
||
910 | e.printStackTrace(); |
||
911 | fail(); |
||
912 | return;
|
||
913 | } |
||
914 | |||
915 | } |
||
916 | |||
917 | } |