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