svn-gvsig-desktop / trunk / org.gvsig.desktop / org.gvsig.desktop.compat.cdc / org.gvsig.fmap.dal / org.gvsig.fmap.dal.impl / src / test / java / org / gvsig / fmap / dal / feature / BaseTestEditableFeatureStore.java @ 40559
History | View | Annotate | Download (34.7 KB)
1 |
/**
|
---|---|
2 |
* gvSIG. Desktop Geographic Information System.
|
3 |
*
|
4 |
* Copyright (C) 2007-2013 gvSIG Association.
|
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 3
|
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 |
* For any additional information, do not hesitate to contact us
|
22 |
* at info AT gvsig.com, or visit our website www.gvsig.com.
|
23 |
*/
|
24 |
/*
|
25 |
* AUTHORS (In addition to CIT):
|
26 |
* 2009 IVER T.I. S.A. {{Task}}
|
27 |
*/
|
28 |
|
29 |
/**
|
30 |
*
|
31 |
*/
|
32 |
package org.gvsig.fmap.dal.feature; |
33 |
|
34 |
import java.util.Iterator; |
35 |
|
36 |
import org.gvsig.fmap.dal.DataServerExplorer; |
37 |
import org.gvsig.fmap.dal.DataStore; |
38 |
import org.gvsig.fmap.dal.DataStoreParameters; |
39 |
import org.gvsig.fmap.dal.DataTypes; |
40 |
import org.gvsig.fmap.dal.exception.DataException; |
41 |
import org.gvsig.fmap.dal.exception.RemoveException; |
42 |
import org.gvsig.fmap.dal.exception.ValidateDataParametersException; |
43 |
import org.gvsig.fmap.dal.feature.exception.ConcurrentDataModificationException; |
44 |
import org.gvsig.fmap.dal.feature.testmulithread.DeleteFirstAndLastFeature; |
45 |
import org.gvsig.fmap.dal.feature.testmulithread.DeleteLastFeature; |
46 |
import org.gvsig.fmap.dal.feature.testmulithread.InsertFeature; |
47 |
import org.gvsig.fmap.dal.feature.testmulithread.StoreTask; |
48 |
import org.gvsig.fmap.dal.feature.testmulithread.UpdateFeature; |
49 |
import org.gvsig.tools.dispose.DisposableIterator; |
50 |
import org.gvsig.tools.evaluator.AbstractEvaluator; |
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.observer.Observable; |
56 |
import org.gvsig.tools.observer.Observer; |
57 |
|
58 |
/**
|
59 |
* @author jmvivo
|
60 |
*
|
61 |
*/
|
62 |
public abstract class BaseTestEditableFeatureStore extends BaseTestFeatureStore { |
63 |
|
64 |
public abstract NewFeatureStoreParameters getDefaultNewDataStoreParameters() |
65 |
throws Exception; |
66 |
|
67 |
public abstract boolean resourcesNotifyChanges(); |
68 |
|
69 |
//=================================================
|
70 |
//=================================================
|
71 |
|
72 |
|
73 |
public void fillPrimaryKeyInserFeature(EditableFeature feature) { |
74 |
return;
|
75 |
} |
76 |
|
77 |
protected Evaluator getEvaluatorToLower(String attibuteName) { |
78 |
return new ToLower(attibuteName); |
79 |
|
80 |
} |
81 |
|
82 |
protected Evaluator getEvaluatorToUpper(String attibuteName) { |
83 |
return new ToUpper(attibuteName); |
84 |
} |
85 |
|
86 |
public class ToLower extends AbstractEvaluator { |
87 |
private String attributeName; |
88 |
|
89 |
public ToLower(String attrName) { |
90 |
this.attributeName = attrName;
|
91 |
this.getFieldsInfo().addFieldValue(this.attributeName); |
92 |
} |
93 |
|
94 |
public Object evaluate(EvaluatorData data) throws EvaluatorException { |
95 |
String value = (String) data.getDataValue(this.attributeName); |
96 |
if (value == null) { |
97 |
return null; |
98 |
} |
99 |
return value.toLowerCase();
|
100 |
} |
101 |
|
102 |
public String getSQL() { |
103 |
return null; |
104 |
} |
105 |
|
106 |
public String getDescription() { |
107 |
return null; |
108 |
} |
109 |
|
110 |
public String getName() { |
111 |
return null; |
112 |
} |
113 |
|
114 |
} |
115 |
|
116 |
public class ToUpper extends AbstractEvaluator { |
117 |
private String attributeName; |
118 |
|
119 |
public ToUpper(String attrName) { |
120 |
this.attributeName = attrName;
|
121 |
this.getFieldsInfo().addFieldValue(this.attributeName); |
122 |
} |
123 |
|
124 |
public Object evaluate(EvaluatorData data) throws EvaluatorException { |
125 |
String value = (String) data.getDataValue(this.attributeName); |
126 |
if (value == null) { |
127 |
return null; |
128 |
} |
129 |
return value.toUpperCase();
|
130 |
} |
131 |
|
132 |
public String getSQL() { |
133 |
return null; |
134 |
} |
135 |
|
136 |
public String getDescription() { |
137 |
return null; |
138 |
} |
139 |
|
140 |
public EvaluatorFieldValue[] getFieldValues(String name) { |
141 |
return null; |
142 |
} |
143 |
|
144 |
public String getName() { |
145 |
return null; |
146 |
} |
147 |
|
148 |
} |
149 |
|
150 |
protected FeatureStore getStoreCopy(FeatureStore source,
|
151 |
NewFeatureStoreParameters targetParams) throws DataException,
|
152 |
ValidateDataParametersException { |
153 |
DataServerExplorer explorer = source.getExplorer(); |
154 |
source.export(explorer, source.getProviderName(), targetParams); |
155 |
FeatureStore result = (FeatureStore) dataManager.openStore(source.getProviderName(), targetParams); |
156 |
|
157 |
return result;
|
158 |
} |
159 |
|
160 |
protected void clearCopy(FeatureStore source, |
161 |
NewFeatureStoreParameters targetParams) throws Exception { |
162 |
DataServerExplorer explorer = source.getExplorer(); |
163 |
explorer.remove(targetParams); |
164 |
|
165 |
} |
166 |
|
167 |
protected boolean compareFeatures(Feature f1, Feature f2, |
168 |
String[] attrsNames, UpdateFeature updated, long index, |
169 |
long lastIndex) throws DataException, EvaluatorException { |
170 |
FeatureAttributeDescriptor attr1; |
171 |
FeatureAttributeDescriptor attr2; |
172 |
EditableFeature f2e = f2.getEditable(); |
173 |
updated.applyUpdateList(f2e, index, lastIndex); |
174 |
|
175 |
Object v1, v2;
|
176 |
for (int i = 0; i < attrsNames.length; i++) { |
177 |
attr1 = f1.getType().getAttributeDescriptor(attrsNames[i]); |
178 |
attr2 = f2e.getType().getAttributeDescriptor(attrsNames[i]); |
179 |
if (attr1 != attr2) {
|
180 |
if (!compareAttributes(attr1, attr1)) {
|
181 |
return false; |
182 |
} |
183 |
} |
184 |
v1 = f1.get(attr1.getName()); |
185 |
v2 = f2.get(attr2.getName()); |
186 |
if (!compareFeatureValue(v1, v2, attr1)) {
|
187 |
return false; |
188 |
} |
189 |
} |
190 |
|
191 |
return true; |
192 |
} |
193 |
|
194 |
protected boolean compareFeatures(Feature f1, Feature f2, |
195 |
UpdateFeature updated, long index, long lastIndex) |
196 |
throws DataException, EvaluatorException {
|
197 |
if (!compareTypes(f1.getType(), f2.getType())) {
|
198 |
System.out.println("compareFeatures() type !="); |
199 |
return false; |
200 |
} |
201 |
Iterator iter = f1.getType().iterator();
|
202 |
FeatureAttributeDescriptor attr; |
203 |
EditableFeature f1e = f1.getEditable(); |
204 |
updated.applyUpdateList(f1e, index, lastIndex); |
205 |
Object v1, v2;
|
206 |
while (iter.hasNext()) {
|
207 |
attr = (FeatureAttributeDescriptor) iter.next(); |
208 |
v1 = f1e.get(attr.getName()); |
209 |
v2 = f2.get(attr.getName()); |
210 |
if (!compareFeatureValue(v1, v2, attr)) {
|
211 |
return false; |
212 |
} |
213 |
} |
214 |
|
215 |
|
216 |
return true; |
217 |
|
218 |
} |
219 |
|
220 |
|
221 |
//---------------
|
222 |
|
223 |
|
224 |
|
225 |
|
226 |
//=================================================
|
227 |
//=================================================
|
228 |
|
229 |
|
230 |
|
231 |
|
232 |
public void testExport() throws Exception { |
233 |
DataStoreParameters parameters = null;
|
234 |
|
235 |
parameters = getDefaultDataStoreParameters(); |
236 |
|
237 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
238 |
|
239 |
NewFeatureStoreParameters newParams = this
|
240 |
.getDefaultNewDataStoreParameters(); |
241 |
try {
|
242 |
this.clearCopy(store, newParams);
|
243 |
} catch (RemoveException e) {
|
244 |
// Dp nothing
|
245 |
} |
246 |
|
247 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
248 |
|
249 |
fullStoreIteratorTest(result); |
250 |
|
251 |
FeatureSet set; |
252 |
FeatureSet originalSet; |
253 |
if (result.getDefaultFeatureType().getPrimaryKey() != null |
254 |
&& result.getDefaultFeatureType().getPrimaryKey().length > 0) {
|
255 |
FeatureQuery queryR = result.createFeatureQuery(); |
256 |
FeatureQuery queryO = store.createFeatureQuery(); |
257 |
FeatureAttributeDescriptor[] pk = result.getDefaultFeatureType()
|
258 |
.getPrimaryKey(); |
259 |
for (int i = 0; i < pk.length; i++) { |
260 |
queryO.getOrder().add(pk[i].getName(), true);
|
261 |
queryR.getOrder().add(pk[i].getName(), true);
|
262 |
} |
263 |
|
264 |
|
265 |
set = result.getFeatureSet(queryR); |
266 |
originalSet = store.getFeatureSet(queryO); |
267 |
|
268 |
|
269 |
} else {
|
270 |
set = result.getFeatureSet(); |
271 |
originalSet = store.getFeatureSet(); |
272 |
} |
273 |
assertEquals(set.getSize(), originalSet.getSize()); |
274 |
|
275 |
DisposableIterator originalIter = originalSet.iterator(); |
276 |
DisposableIterator iter = set.iterator(); |
277 |
assertTrue(compareFeatureIterators(originalIter, iter)); |
278 |
originalIter.dispose(); |
279 |
iter.dispose(); |
280 |
|
281 |
if (store.getEnvelope() != result.getEnvelope()) {
|
282 |
if (store.getEnvelope() != null) { |
283 |
assertTrue(store.getEnvelope().equals(result.getEnvelope())); |
284 |
} else {
|
285 |
fail("Envelope: src=" + store.getEnvelope() + " traget=" |
286 |
+ store.getEnvelope()); |
287 |
} |
288 |
} |
289 |
|
290 |
set.dispose(); |
291 |
originalSet.dispose(); |
292 |
|
293 |
result.dispose(); |
294 |
this.clearCopy(store, newParams);
|
295 |
store.dispose(); |
296 |
|
297 |
} |
298 |
|
299 |
public void testRemove() throws Exception { |
300 |
DataStoreParameters parameters = null;
|
301 |
|
302 |
parameters = getDefaultDataStoreParameters(); |
303 |
|
304 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
305 |
|
306 |
NewFeatureStoreParameters newParams = this
|
307 |
.getDefaultNewDataStoreParameters(); |
308 |
try {
|
309 |
this.clearCopy(store, newParams);
|
310 |
} catch (RemoveException e) {
|
311 |
// Dp nothing
|
312 |
} |
313 |
|
314 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
315 |
|
316 |
result.edit(FeatureStore.MODE_FULLEDIT); |
317 |
|
318 |
FeatureSet set = result.getFeatureSet(getDefaultQuery(result)); |
319 |
FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store)); |
320 |
assertEquals(set.getSize(), originalSet.getSize()); |
321 |
|
322 |
DisposableIterator originalIter = originalSet.iterator(); |
323 |
DisposableIterator iter = set.iterator(); |
324 |
int i = 0; |
325 |
while (iter.hasNext()) {
|
326 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
327 |
(Feature) iter.next())); |
328 |
i++; |
329 |
} |
330 |
|
331 |
iter.remove(); |
332 |
|
333 |
|
334 |
assertEquals(originalSet.getSize() - 1, set.getSize());
|
335 |
|
336 |
iter.dispose(); |
337 |
originalIter.dispose(); |
338 |
|
339 |
|
340 |
originalIter = originalSet.iterator(); |
341 |
iter = set.iterator(); |
342 |
i = 0;
|
343 |
while (iter.hasNext()) {
|
344 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
345 |
(Feature) iter.next())); |
346 |
i++; |
347 |
} |
348 |
|
349 |
iter.remove(); |
350 |
|
351 |
assertEquals(originalSet.getSize() - 2, set.getSize());
|
352 |
|
353 |
iter.dispose(); |
354 |
originalIter.dispose(); |
355 |
|
356 |
set.dispose(); |
357 |
|
358 |
result.finishEditing(); |
359 |
|
360 |
set = result.getFeatureSet(); |
361 |
assertEquals(originalSet.getSize() - 2, set.getSize());
|
362 |
|
363 |
originalIter = originalSet.iterator(); |
364 |
iter = set.iterator(); |
365 |
i = 0;
|
366 |
while (iter.hasNext()) {
|
367 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
368 |
(Feature) iter.next())); |
369 |
i++; |
370 |
} |
371 |
|
372 |
iter.dispose(); |
373 |
originalIter.dispose(); |
374 |
|
375 |
|
376 |
set.dispose(); |
377 |
originalSet.dispose(); |
378 |
|
379 |
result.dispose(); |
380 |
this.clearCopy(store, newParams);
|
381 |
store.dispose(); |
382 |
|
383 |
|
384 |
} |
385 |
|
386 |
public void testInsert() throws Exception { |
387 |
DataStoreParameters parameters = null;
|
388 |
|
389 |
parameters = getDefaultDataStoreParameters(); |
390 |
|
391 |
|
392 |
FeatureStore store = (FeatureStore) dataManager |
393 |
.createStore(parameters); |
394 |
|
395 |
NewFeatureStoreParameters newParams = this
|
396 |
.getDefaultNewDataStoreParameters(); |
397 |
try {
|
398 |
this.clearCopy(store, newParams);
|
399 |
} catch (RemoveException e) {
|
400 |
//Do nothing
|
401 |
} |
402 |
|
403 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
404 |
|
405 |
result.edit(FeatureStore.MODE_FULLEDIT); |
406 |
|
407 |
FeatureSet set = result.getFeatureSet(getDefaultQuery(result)); |
408 |
FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store)); |
409 |
assertEquals(set.getSize(), originalSet.getSize()); |
410 |
|
411 |
EditableFeature newFeature = result.createNewFeature(true);
|
412 |
fillPrimaryKeyInserFeature(newFeature); |
413 |
set.insert(newFeature); |
414 |
DisposableIterator originalIter = originalSet.iterator(); |
415 |
DisposableIterator iter = set.iterator(); |
416 |
int i = 0; |
417 |
while (originalIter.hasNext()) {
|
418 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
419 |
.next(), (Feature) iter.next())); |
420 |
i++; |
421 |
} |
422 |
assertTrue(iter.hasNext()); |
423 |
assertNotNull(iter.next()); |
424 |
assertFalse(iter.hasNext()); |
425 |
|
426 |
assertEquals(originalSet.getSize() + 1, set.getSize());
|
427 |
|
428 |
iter.dispose(); |
429 |
originalIter.dispose(); |
430 |
|
431 |
originalIter = originalSet.iterator(); |
432 |
iter = set.iterator(); |
433 |
i = 0;
|
434 |
while (originalIter.hasNext()) {
|
435 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
436 |
.next(), (Feature) iter.next())); |
437 |
i++; |
438 |
} |
439 |
assertTrue(iter.hasNext()); |
440 |
assertNotNull(iter.next()); |
441 |
|
442 |
newFeature = result.createNewFeature(true);
|
443 |
fillPrimaryKeyInserFeature(newFeature); |
444 |
set.insert(newFeature); |
445 |
|
446 |
assertEquals(originalSet.getSize() + 2, set.getSize());
|
447 |
|
448 |
iter.dispose(); |
449 |
originalIter.dispose(); |
450 |
|
451 |
set.dispose(); |
452 |
|
453 |
result.finishEditing(); |
454 |
|
455 |
set = result.getFeatureSet(); |
456 |
assertEquals(originalSet.getSize() + 2, set.getSize());
|
457 |
|
458 |
originalIter = originalSet.iterator(); |
459 |
iter = set.iterator(); |
460 |
i = 0;
|
461 |
while (originalIter.hasNext()) {
|
462 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
463 |
.next(), (Feature) iter.next())); |
464 |
i++; |
465 |
} |
466 |
|
467 |
assertNotNull(iter.next()); |
468 |
assertNotNull(iter.next()); |
469 |
assertFalse(iter.hasNext()); |
470 |
|
471 |
iter.dispose(); |
472 |
originalIter.dispose(); |
473 |
|
474 |
set.dispose(); |
475 |
originalSet.dispose(); |
476 |
|
477 |
result.dispose(); |
478 |
this.clearCopy(store, newParams);
|
479 |
store.dispose(); |
480 |
|
481 |
|
482 |
} |
483 |
|
484 |
|
485 |
|
486 |
public void testConcurrentRemove() throws Exception { |
487 |
DataStoreParameters parameters = null;
|
488 |
|
489 |
parameters = getDefaultDataStoreParameters(); |
490 |
|
491 |
|
492 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
493 |
|
494 |
NewFeatureStoreParameters newParams = this
|
495 |
.getDefaultNewDataStoreParameters(); |
496 |
try {
|
497 |
this.clearCopy(store, newParams);
|
498 |
} catch (RemoveException e) {
|
499 |
// Dp nothing
|
500 |
} |
501 |
|
502 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
503 |
|
504 |
result.edit(FeatureStore.MODE_FULLEDIT); |
505 |
|
506 |
DeleteFirstAndLastFeature deleteFeature = new DeleteFirstAndLastFeature(
|
507 |
"1", result, StoreTask.TIME_TO_WAIT_NO_WAIT);
|
508 |
|
509 |
FeatureSet set = result.getFeatureSet(); |
510 |
|
511 |
DisposableIterator iter = set.iterator(); |
512 |
assertTrue(iter.hasNext()); |
513 |
assertNotNull(iter.next()); |
514 |
|
515 |
deleteFeature.start(); |
516 |
|
517 |
while (deleteFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {
|
518 |
Thread.yield();
|
519 |
Thread.sleep(100); |
520 |
if (deleteFeature.isOutOfDate()) {
|
521 |
break;
|
522 |
} |
523 |
} |
524 |
|
525 |
assertEquals(deleteFeature.getCurrentStatus(), |
526 |
StoreTask.STATUS_FINISHED_OK); |
527 |
|
528 |
Exception ex = null; |
529 |
try {
|
530 |
iter.next(); |
531 |
} catch (Exception e) { |
532 |
ex = e; |
533 |
} |
534 |
assertNotNull(ex); |
535 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
536 |
|
537 |
ex = null;
|
538 |
try {
|
539 |
set.getSize(); |
540 |
} catch (Exception e) { |
541 |
ex = e; |
542 |
} |
543 |
assertNotNull(ex); |
544 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
545 |
|
546 |
iter.dispose(); |
547 |
result.dispose(); |
548 |
this.clearCopy(store, newParams);
|
549 |
store.dispose(); |
550 |
|
551 |
} |
552 |
|
553 |
public void testConcurrentInsert() throws Exception{ |
554 |
DataStoreParameters parameters = null;
|
555 |
|
556 |
parameters = getDefaultDataStoreParameters(); |
557 |
|
558 |
|
559 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
560 |
|
561 |
NewFeatureStoreParameters newParams = this
|
562 |
.getDefaultNewDataStoreParameters(); |
563 |
try {
|
564 |
this.clearCopy(store, newParams);
|
565 |
} catch (RemoveException e) {
|
566 |
// Dp nothing
|
567 |
} |
568 |
|
569 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
570 |
|
571 |
result.edit(FeatureStore.MODE_FULLEDIT); |
572 |
|
573 |
InsertFeature insertFeature = new InsertFeature("1", result, |
574 |
StoreTask.TIME_TO_WAIT_NO_WAIT, this);
|
575 |
|
576 |
FeatureSet set = result.getFeatureSet(); |
577 |
|
578 |
DisposableIterator iter = set.iterator(); |
579 |
assertTrue(iter.hasNext()); |
580 |
assertNotNull(iter.next()); |
581 |
|
582 |
insertFeature.start(); |
583 |
|
584 |
while (insertFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {
|
585 |
Thread.yield();
|
586 |
Thread.sleep(100); |
587 |
if (insertFeature.isOutOfDate()) {
|
588 |
break;
|
589 |
} |
590 |
} |
591 |
|
592 |
assertEquals(StoreTask.STATUS_FINISHED_OK, insertFeature |
593 |
.getCurrentStatus()); |
594 |
|
595 |
Exception ex = null; |
596 |
try {
|
597 |
iter.next(); |
598 |
} catch (Exception e) { |
599 |
ex = e; |
600 |
} |
601 |
assertNotNull(ex); |
602 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
603 |
|
604 |
ex = null;
|
605 |
try {
|
606 |
set.getSize(); |
607 |
} catch (Exception e) { |
608 |
ex = e; |
609 |
} |
610 |
assertNotNull(ex); |
611 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
612 |
|
613 |
iter.dispose(); |
614 |
result.dispose(); |
615 |
this.clearCopy(store, newParams);
|
616 |
store.dispose(); |
617 |
} |
618 |
|
619 |
public void testConcurrentUpdate() throws Exception { |
620 |
DataStoreParameters parameters = null;
|
621 |
|
622 |
parameters = getDefaultDataStoreParameters(); |
623 |
|
624 |
|
625 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
626 |
|
627 |
NewFeatureStoreParameters newParams = this
|
628 |
.getDefaultNewDataStoreParameters(); |
629 |
try {
|
630 |
this.clearCopy(store, newParams);
|
631 |
} catch (RemoveException e) {
|
632 |
// Dp nothing
|
633 |
} |
634 |
|
635 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
636 |
|
637 |
|
638 |
result.edit(FeatureStore.MODE_FULLEDIT); |
639 |
|
640 |
UpdateFeature updateFeature = new UpdateFeature("1", result, |
641 |
StoreTask.TIME_TO_WAIT_NO_WAIT); |
642 |
|
643 |
FeatureType fType = result.getDefaultFeatureType(); |
644 |
FeatureAttributeDescriptor attr; |
645 |
Iterator fTypeIter = fType.iterator();
|
646 |
String attrName = null; |
647 |
while (fTypeIter.hasNext()){
|
648 |
attr = (FeatureAttributeDescriptor) fTypeIter.next(); |
649 |
if (attr.getType() == DataTypes.STRING && !attr.isReadOnly() && !attr.isPrimaryKey() && !attr.isAutomatic()){
|
650 |
attrName= attr.getName(); |
651 |
} |
652 |
} |
653 |
if (attrName == null) { |
654 |
fail("This test needs an normal attribute String (no Pk, no ReadOnly & no Auto)");
|
655 |
return;
|
656 |
} |
657 |
|
658 |
|
659 |
updateFeature.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attrName, |
660 |
"XXX");
|
661 |
|
662 |
FeatureSet set = result.getFeatureSet(); |
663 |
|
664 |
DisposableIterator iter = set.iterator(); |
665 |
assertTrue(iter.hasNext()); |
666 |
assertNotNull(iter.next()); |
667 |
|
668 |
updateFeature.start(); |
669 |
|
670 |
while (updateFeature.getCurrentStatus() <= StoreTask.STATUS_RUNING) {
|
671 |
Thread.yield();
|
672 |
Thread.sleep(100); |
673 |
if (updateFeature.isOutOfDate()) {
|
674 |
break;
|
675 |
} |
676 |
} |
677 |
|
678 |
assertEquals(StoreTask.STATUS_FINISHED_OK, updateFeature |
679 |
.getCurrentStatus()); |
680 |
|
681 |
Exception ex = null; |
682 |
try {
|
683 |
iter.next(); |
684 |
} catch (Exception e) { |
685 |
ex = e; |
686 |
} |
687 |
assertNotNull(ex); |
688 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
689 |
|
690 |
ex = null;
|
691 |
try {
|
692 |
set.getSize(); |
693 |
} catch (Exception e) { |
694 |
ex = e; |
695 |
} |
696 |
assertNotNull(ex); |
697 |
assertEquals(ConcurrentDataModificationException.class, ex.getClass()); |
698 |
|
699 |
iter.dispose(); |
700 |
result.dispose(); |
701 |
this.clearCopy(store, newParams);
|
702 |
store.dispose(); |
703 |
|
704 |
|
705 |
|
706 |
} |
707 |
|
708 |
public void testSequencedRemove() throws Exception { |
709 |
DataStoreParameters parameters = null;
|
710 |
|
711 |
int ntimes = 3; |
712 |
|
713 |
parameters = getDefaultDataStoreParameters(); |
714 |
|
715 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
716 |
|
717 |
NewFeatureStoreParameters newParams = this
|
718 |
.getDefaultNewDataStoreParameters(); |
719 |
try {
|
720 |
this.clearCopy(store, newParams);
|
721 |
} catch (RemoveException e) {
|
722 |
// Dp nothing
|
723 |
} |
724 |
|
725 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
726 |
|
727 |
result.edit(FeatureStore.MODE_FULLEDIT); |
728 |
|
729 |
DeleteLastFeature[] deletesFeature = new DeleteLastFeature[ntimes]; |
730 |
int i;
|
731 |
for (i = 0; i < deletesFeature.length; i++) { |
732 |
deletesFeature[i] = new DeleteLastFeature("DeleteLastFeature:" + i, |
733 |
result, 300 * i);
|
734 |
} |
735 |
|
736 |
for (i = 0; i < deletesFeature.length; i++) { |
737 |
deletesFeature[i].start(); |
738 |
} |
739 |
|
740 |
try {
|
741 |
for (int x = 0; x < (deletesFeature.length + 2); x++) { |
742 |
Thread.yield();
|
743 |
Thread.sleep(500); |
744 |
} |
745 |
|
746 |
} catch (InterruptedException e) { |
747 |
e.printStackTrace(); |
748 |
result.dispose(); |
749 |
fail(); |
750 |
return;
|
751 |
} |
752 |
|
753 |
boolean testAll = false; |
754 |
boolean restart;
|
755 |
DeleteLastFeature item; |
756 |
while (!testAll) {
|
757 |
restart = false;
|
758 |
for (i = 0; i < deletesFeature.length; i++) { |
759 |
item = deletesFeature[i]; |
760 |
if (item.getCurrentStatus() <= StoreTask.STATUS_RUNING) {
|
761 |
if (item.isOutOfDate()) {
|
762 |
result.dispose(); |
763 |
fail("OutOfDate: " + i);
|
764 |
return;
|
765 |
} |
766 |
try {
|
767 |
Thread.yield();
|
768 |
Thread.sleep(400); |
769 |
} catch (InterruptedException e) { |
770 |
e.printStackTrace(); |
771 |
result.dispose(); |
772 |
fail(); |
773 |
return;
|
774 |
} |
775 |
restart = true;
|
776 |
break;
|
777 |
} else if (item.getCurrentStatus() == StoreTask.STATUS_ERROR) { |
778 |
item.getException().printStackTrace(); |
779 |
result.dispose(); |
780 |
fail("ERROR: " + i);
|
781 |
return;
|
782 |
} else if (item.getCurrentStatus() != StoreTask.STATUS_FINISHED_OK) { |
783 |
item.getException().printStackTrace(); |
784 |
result.dispose(); |
785 |
fail("Data ERROR: " + i);
|
786 |
return;
|
787 |
} |
788 |
} |
789 |
if (restart) {
|
790 |
continue;
|
791 |
} |
792 |
testAll = true;
|
793 |
} |
794 |
|
795 |
FeatureSet set = result.getFeatureSet(getDefaultQuery(result)); |
796 |
FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store)); |
797 |
assertEquals(originalSet.getSize() - deletesFeature.length, set |
798 |
.getSize()); |
799 |
|
800 |
DisposableIterator originalIter = originalSet.iterator(); |
801 |
DisposableIterator iter = set.iterator(); |
802 |
|
803 |
i = 0;
|
804 |
while (iter.hasNext()) {
|
805 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
806 |
(Feature) iter.next())); |
807 |
i++; |
808 |
} |
809 |
|
810 |
originalIter.dispose(); |
811 |
iter.dispose(); |
812 |
|
813 |
set.dispose(); |
814 |
|
815 |
result.finishEditing(); |
816 |
|
817 |
set = result.getFeatureSet(getDefaultQuery(result)); |
818 |
assertEquals(originalSet.getSize() - deletesFeature.length, set |
819 |
.getSize()); |
820 |
|
821 |
originalIter = originalSet.iterator(); |
822 |
iter = set.iterator(); |
823 |
i = 0;
|
824 |
while (iter.hasNext()) {
|
825 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
826 |
(Feature) iter.next())); |
827 |
i++; |
828 |
} |
829 |
|
830 |
|
831 |
originalIter.dispose(); |
832 |
iter.dispose(); |
833 |
|
834 |
set.dispose(); |
835 |
originalSet.dispose(); |
836 |
|
837 |
result.dispose(); |
838 |
this.clearCopy(store, newParams);
|
839 |
store.dispose(); |
840 |
} |
841 |
|
842 |
public void testSequencedInsert() throws Exception { |
843 |
DataStoreParameters parameters = null;
|
844 |
|
845 |
int ntimes = 3; |
846 |
|
847 |
parameters = getDefaultDataStoreParameters(); |
848 |
|
849 |
|
850 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
851 |
|
852 |
NewFeatureStoreParameters newParams = this
|
853 |
.getDefaultNewDataStoreParameters(); |
854 |
try {
|
855 |
this.clearCopy(store, newParams);
|
856 |
} catch (RemoveException e) {
|
857 |
// Dp nothing
|
858 |
} |
859 |
|
860 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
861 |
|
862 |
result.edit(FeatureStore.MODE_FULLEDIT); |
863 |
|
864 |
InsertFeature[] insertsFeature = new InsertFeature[ntimes]; |
865 |
int i;
|
866 |
for (i = 0; i < insertsFeature.length; i++) { |
867 |
insertsFeature[i] = new InsertFeature("InsertFeature:" + i, result, |
868 |
300 * i, this); |
869 |
} |
870 |
|
871 |
for (i = 0; i < insertsFeature.length; i++) { |
872 |
insertsFeature[i].start(); |
873 |
} |
874 |
|
875 |
try {
|
876 |
|
877 |
for (int x = 0; x < (insertsFeature.length + 2); x++) { |
878 |
Thread.yield();
|
879 |
Thread.sleep(500); |
880 |
} |
881 |
|
882 |
} catch (InterruptedException e) { |
883 |
e.printStackTrace(); |
884 |
result.dispose(); |
885 |
fail(); |
886 |
return;
|
887 |
} |
888 |
|
889 |
boolean testAll = false; |
890 |
boolean restart;
|
891 |
InsertFeature item; |
892 |
while (!testAll) {
|
893 |
restart = false;
|
894 |
for (i = 0; i < insertsFeature.length; i++) { |
895 |
item = insertsFeature[i]; |
896 |
if (item.getCurrentStatus() <= StoreTask.STATUS_RUNING) {
|
897 |
if (item.isOutOfDate()) {
|
898 |
result.dispose(); |
899 |
fail("OutOfDate: " + i);
|
900 |
return;
|
901 |
} |
902 |
try {
|
903 |
Thread.yield();
|
904 |
Thread.sleep(400); |
905 |
} catch (InterruptedException e) { |
906 |
e.printStackTrace(); |
907 |
result.dispose(); |
908 |
fail(); |
909 |
return;
|
910 |
} |
911 |
restart = true;
|
912 |
break;
|
913 |
} else if (item.getCurrentStatus() == StoreTask.STATUS_ERROR) { |
914 |
item.getException().printStackTrace(); |
915 |
result.dispose(); |
916 |
fail("ERROR: " + i);
|
917 |
return;
|
918 |
} else if (item.getCurrentStatus() == StoreTask.STATUS_FINISHED_NO_OK) { |
919 |
result.dispose(); |
920 |
fail("No OK: " + i);
|
921 |
return;
|
922 |
} else if (item.getCurrentStatus() != StoreTask.STATUS_FINISHED_OK) { |
923 |
item.getException().printStackTrace(); |
924 |
result.dispose(); |
925 |
fail("Data ERROR: " + i);
|
926 |
return;
|
927 |
|
928 |
} |
929 |
} |
930 |
if (restart) {
|
931 |
continue;
|
932 |
} |
933 |
testAll = true;
|
934 |
} |
935 |
|
936 |
FeatureSet set = result.getFeatureSet(getDefaultQuery(result)); |
937 |
FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store)); |
938 |
assertEquals(originalSet.getSize() + insertsFeature.length, set |
939 |
.getSize()); |
940 |
|
941 |
DisposableIterator originalIter = originalSet.iterator(); |
942 |
DisposableIterator iter = set.iterator(); |
943 |
|
944 |
i = 0;
|
945 |
while (originalIter.hasNext()) {
|
946 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
947 |
(Feature) iter.next())); |
948 |
i++; |
949 |
} |
950 |
for (; i < insertsFeature.length; i++) {
|
951 |
iter.next(); |
952 |
} |
953 |
|
954 |
|
955 |
originalIter.dispose(); |
956 |
iter.dispose(); |
957 |
|
958 |
set.dispose(); |
959 |
|
960 |
result.finishEditing(); |
961 |
|
962 |
set = result.getFeatureSet(); |
963 |
assertEquals(originalSet.getSize() + insertsFeature.length, set |
964 |
.getSize()); |
965 |
|
966 |
originalIter = originalSet.iterator(); |
967 |
iter = set.iterator(); |
968 |
i = 0;
|
969 |
while (originalIter.hasNext()) {
|
970 |
assertTrue("" + i, compareFeatures((Feature) originalIter.next(),
|
971 |
(Feature) iter.next())); |
972 |
i++; |
973 |
} |
974 |
for (; i < insertsFeature.length; i++) {
|
975 |
iter.next(); |
976 |
} |
977 |
|
978 |
set.dispose(); |
979 |
originalSet.dispose(); |
980 |
|
981 |
result.dispose(); |
982 |
this.clearCopy(store, newParams);
|
983 |
store.dispose(); |
984 |
|
985 |
} |
986 |
|
987 |
|
988 |
public void testUpdate() throws Exception { |
989 |
DataStoreParameters parameters = null;
|
990 |
|
991 |
parameters = getDefaultDataStoreParameters(); |
992 |
|
993 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
994 |
|
995 |
NewFeatureStoreParameters newParams = this
|
996 |
.getDefaultNewDataStoreParameters(); |
997 |
try {
|
998 |
this.clearCopy(store, newParams);
|
999 |
} catch (RemoveException e) {
|
1000 |
// Dp nothing
|
1001 |
} |
1002 |
|
1003 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
1004 |
|
1005 |
result.edit(FeatureStore.MODE_FULLEDIT); |
1006 |
|
1007 |
FeatureSet set = result.getFeatureSet(); |
1008 |
long size = set.getSize();
|
1009 |
|
1010 |
set.dispose(); |
1011 |
|
1012 |
UpdateFeature updater = new UpdateFeature("1", result, |
1013 |
UpdateFeature.TIME_TO_WAIT_NO_WAIT); |
1014 |
FeatureAttributeDescriptor attr = getFirstAttributeOfType(result |
1015 |
.getDefaultFeatureType(), DataTypes.STRING); |
1016 |
assertNotNull("No String attributes found", attr);
|
1017 |
|
1018 |
updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attr.getName(), |
1019 |
getEvaluatorToLower(attr.getName())); |
1020 |
|
1021 |
updater.run(); |
1022 |
while (updater.getCurrentStatus() < StoreTask.STATUS_FINISHED_OK
|
1023 |
&& !updater.isOutOfDate()) { |
1024 |
Thread.yield();
|
1025 |
try {
|
1026 |
Thread.sleep(200); |
1027 |
} catch (InterruptedException e) { |
1028 |
e.printStackTrace(); |
1029 |
fail(); |
1030 |
} |
1031 |
} |
1032 |
set = result.getFeatureSet(getDefaultQuery(result)); |
1033 |
DisposableIterator iter = set.iterator(); |
1034 |
|
1035 |
printFeatureTypeColNames(set.getDefaultFeatureType(), 15);
|
1036 |
Feature f; |
1037 |
while (iter.hasNext()) {
|
1038 |
f = (Feature) iter.next(); |
1039 |
this.printFeature(f, false, 15); |
1040 |
} |
1041 |
|
1042 |
iter.dispose(); |
1043 |
|
1044 |
FeatureSet originalSet = store.getFeatureSet(getDefaultQuery(store)); |
1045 |
|
1046 |
DisposableIterator originalIter = originalSet.iterator(); |
1047 |
|
1048 |
iter = set.iterator(); |
1049 |
|
1050 |
long i = 0; |
1051 |
while (originalIter.hasNext()) {
|
1052 |
try {
|
1053 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
1054 |
.next(), (Feature) iter.next(), updater, i, size)); |
1055 |
} catch (EvaluatorException e) {
|
1056 |
e.printStackTrace(); |
1057 |
fail(); |
1058 |
} |
1059 |
i++; |
1060 |
} |
1061 |
iter.dispose(); |
1062 |
originalIter.dispose(); |
1063 |
|
1064 |
|
1065 |
set.dispose(); |
1066 |
|
1067 |
result.finishEditing(); |
1068 |
|
1069 |
set = result.getFeatureSet(); |
1070 |
assertEquals(originalSet.getSize(), set.getSize()); |
1071 |
|
1072 |
originalIter = originalSet.iterator(); |
1073 |
iter = set.iterator(); |
1074 |
i = 0;
|
1075 |
while (originalIter.hasNext()) {
|
1076 |
try {
|
1077 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
1078 |
.next(), (Feature) iter.next(), updater, i, size)); |
1079 |
} catch (EvaluatorException e) {
|
1080 |
e.printStackTrace(); |
1081 |
fail(); |
1082 |
} |
1083 |
i++; |
1084 |
} |
1085 |
|
1086 |
|
1087 |
iter.dispose(); |
1088 |
originalIter.dispose(); |
1089 |
set.dispose(); |
1090 |
|
1091 |
|
1092 |
updater = new UpdateFeature("1", result, |
1093 |
UpdateFeature.TIME_TO_WAIT_NO_WAIT); |
1094 |
|
1095 |
updater.addUpdate(UpdateFeature.UPDATE_ALL_FEATURES, attr.getName(), |
1096 |
getEvaluatorToLower(attr.getName())); |
1097 |
|
1098 |
updater.run(); |
1099 |
while (updater.getCurrentStatus() < StoreTask.STATUS_FINISHED_OK
|
1100 |
&& !updater.isOutOfDate()) { |
1101 |
Thread.yield();
|
1102 |
try {
|
1103 |
Thread.sleep(200); |
1104 |
} catch (InterruptedException e) { |
1105 |
e.printStackTrace(); |
1106 |
fail(); |
1107 |
} |
1108 |
} |
1109 |
set = result.getFeatureSet(); |
1110 |
|
1111 |
iter = set.iterator(); |
1112 |
originalIter = originalSet.iterator(); |
1113 |
i = 0;
|
1114 |
while (originalIter.hasNext()) {
|
1115 |
try {
|
1116 |
assertTrue("" + i, compareFeatures((Feature) originalIter
|
1117 |
.next(), (Feature) iter.next(), updater, i, size)); |
1118 |
} catch (EvaluatorException e) {
|
1119 |
e.printStackTrace(); |
1120 |
fail(); |
1121 |
} |
1122 |
i++; |
1123 |
} |
1124 |
|
1125 |
iter.dispose(); |
1126 |
originalIter.dispose(); |
1127 |
set.dispose(); |
1128 |
|
1129 |
|
1130 |
|
1131 |
|
1132 |
|
1133 |
originalSet.dispose(); |
1134 |
|
1135 |
result.dispose(); |
1136 |
this.clearCopy(store, newParams);
|
1137 |
store.dispose(); |
1138 |
|
1139 |
} |
1140 |
|
1141 |
|
1142 |
public void testResourceChangeNotification() throws Exception{ |
1143 |
if (!resourcesNotifyChanges()) {
|
1144 |
return;
|
1145 |
} |
1146 |
|
1147 |
DataStoreParameters parameters = null;
|
1148 |
|
1149 |
parameters = getDefaultDataStoreParameters(); |
1150 |
|
1151 |
FeatureStore store = (FeatureStore) dataManager.createStore(parameters); |
1152 |
|
1153 |
NewFeatureStoreParameters newParams = this
|
1154 |
.getDefaultNewDataStoreParameters(); |
1155 |
try {
|
1156 |
this.clearCopy(store, newParams);
|
1157 |
} catch (RemoveException e) {
|
1158 |
// Dp nothing
|
1159 |
} |
1160 |
|
1161 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
1162 |
|
1163 |
FeatureStore result2 = (FeatureStore) dataManager |
1164 |
.createStore(newParams); |
1165 |
|
1166 |
FeatureAttributeDescriptor attr = getFirstAttributeOfType(result |
1167 |
.getDefaultFeatureType(), DataTypes.STRING); |
1168 |
assertNotNull("No String attributes found", attr);
|
1169 |
|
1170 |
|
1171 |
UpdateFeature updater = new UpdateFeature("1", result, |
1172 |
UpdateFeature.TIME_TO_WAIT_NO_WAIT); |
1173 |
|
1174 |
updater.addUpdate(UpdateFeature.UPDATE_LAST_FEATURE, attr.getName(), |
1175 |
getEvaluatorToLower(attr.getName())); |
1176 |
|
1177 |
StoreObserverForNotify observer = new StoreObserverForNotify(result2,
|
1178 |
FeatureStoreNotification.RESOURCE_CHANGED); |
1179 |
result2.addObserver(observer); |
1180 |
|
1181 |
result.edit(); |
1182 |
updater.run(); |
1183 |
while (updater.getCurrentStatus() < StoreTask.STATUS_FINISHED_OK
|
1184 |
&& !updater.isOutOfDate()) { |
1185 |
Thread.yield();
|
1186 |
try {
|
1187 |
Thread.sleep(200); |
1188 |
} catch (InterruptedException e) { |
1189 |
e.printStackTrace(); |
1190 |
fail(); |
1191 |
} |
1192 |
} |
1193 |
|
1194 |
result.finishEditing(); |
1195 |
|
1196 |
assertTrue("The observer hasn't been notified", observer.notified());
|
1197 |
|
1198 |
result2.refresh(); |
1199 |
|
1200 |
FeatureSet set = result.getFeatureSet(); |
1201 |
FeatureSet set2 = result2.getFeatureSet(); |
1202 |
|
1203 |
DisposableIterator iter1 = set.iterator(); |
1204 |
DisposableIterator iter2 = set2.iterator(); |
1205 |
assertTrue(this.compareFeatureIterators(iter1, iter2));
|
1206 |
iter1.dispose(); |
1207 |
iter2.dispose(); |
1208 |
|
1209 |
set2.dispose(); |
1210 |
set.dispose(); |
1211 |
|
1212 |
// TODO checks FeatureType change
|
1213 |
|
1214 |
result2.dispose(); |
1215 |
result.dispose(); |
1216 |
this.clearCopy(store, newParams);
|
1217 |
store.dispose(); |
1218 |
} |
1219 |
|
1220 |
public abstract class StoreObserver implements Observer{ |
1221 |
|
1222 |
public DataStore store = null; |
1223 |
|
1224 |
} |
1225 |
|
1226 |
public class StoreObserverForNotify implements Observer{ |
1227 |
|
1228 |
public DataStore store = null; |
1229 |
|
1230 |
public String notifyType = null; |
1231 |
|
1232 |
private boolean notifyRecived = false; |
1233 |
|
1234 |
public StoreObserverForNotify(DataStore store,String notifyType){ |
1235 |
this.store = store;
|
1236 |
this.notifyType = notifyType;
|
1237 |
this.notifyRecived = false; |
1238 |
} |
1239 |
|
1240 |
public boolean notified(){ |
1241 |
return notifyRecived;
|
1242 |
} |
1243 |
|
1244 |
public void update(Observable observable, Object notification) { |
1245 |
if (!(observable == this.store)){ |
1246 |
return;
|
1247 |
} |
1248 |
if (!(notification instanceof FeatureStoreNotification)){ |
1249 |
return;
|
1250 |
} |
1251 |
FeatureStoreNotification fsNotification = (FeatureStoreNotification) notification; |
1252 |
|
1253 |
if (fsNotification.getType().equals(this.notifyType)){ |
1254 |
notifyRecived = true;
|
1255 |
} |
1256 |
} |
1257 |
|
1258 |
} |
1259 |
|
1260 |
public void testUpdateFeatureType_AddField() throws Exception { |
1261 |
DataStoreParameters parameters = null;
|
1262 |
|
1263 |
parameters = getDefaultDataStoreParameters(); |
1264 |
|
1265 |
FeatureStore store = (FeatureStore) dataManager |
1266 |
.createStore(parameters); |
1267 |
|
1268 |
NewFeatureStoreParameters newParams = this
|
1269 |
.getDefaultNewDataStoreParameters(); |
1270 |
try {
|
1271 |
this.clearCopy(store, newParams);
|
1272 |
} catch (RemoveException e) {
|
1273 |
// Dp nothing
|
1274 |
} |
1275 |
|
1276 |
int pkAttributesCount = 0; |
1277 |
|
1278 |
FeatureStore result = this.getStoreCopy(store, newParams);
|
1279 |
|
1280 |
result.edit(); |
1281 |
|
1282 |
|
1283 |
String[] orgAttNames = new String[result.getDefaultFeatureType() |
1284 |
.size()]; |
1285 |
|
1286 |
Iterator iter = result.getDefaultFeatureType().iterator();
|
1287 |
int i = 0; |
1288 |
|
1289 |
while (iter.hasNext()) {
|
1290 |
FeatureAttributeDescriptor attr = ((FeatureAttributeDescriptor) iter |
1291 |
.next()); |
1292 |
orgAttNames[i] = attr.getName(); |
1293 |
i++; |
1294 |
if (attr.isPrimaryKey()) {
|
1295 |
pkAttributesCount++; |
1296 |
} |
1297 |
} |
1298 |
|
1299 |
EditableFeatureType edFtype = result |
1300 |
.getDefaultFeatureType().getEditable(); |
1301 |
|
1302 |
edFtype.add("__ATTR1__", DataTypes.STRING).setSize(10) |
1303 |
.setDefaultValue( |
1304 |
"HOLA");
|
1305 |
|
1306 |
result.update(edFtype); |
1307 |
|
1308 |
assertEquals(store.getDefaultFeatureType().size() + 1, result
|
1309 |
.getDefaultFeatureType().size()); |
1310 |
|
1311 |
testIterationFastAndStandart(result); |
1312 |
|
1313 |
FeatureSet orgSet = store.getFeatureSet(getDefaultQuery(store)); |
1314 |
FeatureSet curSet = result.getFeatureSet(getDefaultQuery(result)); |
1315 |
|
1316 |
assertEquals(orgSet.getDefaultFeatureType().size() + 1, curSet
|
1317 |
.getDefaultFeatureType().size()); |
1318 |
|
1319 |
DisposableIterator orgIter = orgSet.iterator(); |
1320 |
DisposableIterator curIter = curSet.iterator(); |
1321 |
|
1322 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1323 |
|
1324 |
orgIter.dispose(); |
1325 |
curIter.dispose(); |
1326 |
|
1327 |
orgIter = orgSet.fastIterator(); |
1328 |
curIter = curSet.fastIterator(); |
1329 |
|
1330 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1331 |
orgIter.dispose(); |
1332 |
curIter.dispose(); |
1333 |
|
1334 |
orgIter = orgSet.iterator(); |
1335 |
curIter = curSet.fastIterator(); |
1336 |
|
1337 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1338 |
orgIter.dispose(); |
1339 |
curIter.dispose(); |
1340 |
|
1341 |
orgIter = orgSet.fastIterator(); |
1342 |
curIter = curSet.iterator(); |
1343 |
|
1344 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1345 |
orgIter.dispose(); |
1346 |
curIter.dispose(); |
1347 |
|
1348 |
curIter = curSet.iterator(); |
1349 |
Feature feature; |
1350 |
while (curIter.hasNext()) {
|
1351 |
feature = (Feature) curIter.next(); |
1352 |
assertEquals("HOLA", feature.get("__ATTR1__")); |
1353 |
} |
1354 |
curIter.dispose(); |
1355 |
curSet.dispose(); |
1356 |
|
1357 |
FeatureQuery query = this.getDefaultQuery(result);
|
1358 |
query.setAttributeNames(new String[] { "__ATTR1__" }); |
1359 |
curSet = result.getFeatureSet(query); |
1360 |
|
1361 |
assertEquals(1 + pkAttributesCount, curSet.getDefaultFeatureType()
|
1362 |
.size()); |
1363 |
|
1364 |
assertEquals(orgSet.getSize(), curSet.getSize()); |
1365 |
curIter = curSet.iterator(); |
1366 |
while (curIter.hasNext()) {
|
1367 |
feature = (Feature) curIter.next(); |
1368 |
assertEquals("HOLA", feature.get("__ATTR1__")); |
1369 |
} |
1370 |
curIter.dispose(); |
1371 |
curSet.dispose(); |
1372 |
|
1373 |
result.finishEditing(); |
1374 |
|
1375 |
testIterationFastAndStandart(result); |
1376 |
|
1377 |
assertEquals(store.getDefaultFeatureType().size() + 1, result
|
1378 |
.getDefaultFeatureType().size()); |
1379 |
|
1380 |
|
1381 |
orgSet = store.getFeatureSet(getDefaultQuery(store)); |
1382 |
curSet = result.getFeatureSet(getDefaultQuery(result)); |
1383 |
|
1384 |
assertEquals(orgSet.getDefaultFeatureType().size() + 1, curSet
|
1385 |
.getDefaultFeatureType().size()); |
1386 |
|
1387 |
orgIter = orgSet.iterator(); |
1388 |
curIter = curSet.iterator(); |
1389 |
|
1390 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1391 |
orgIter.dispose(); |
1392 |
curIter.dispose(); |
1393 |
|
1394 |
orgIter = orgSet.fastIterator(); |
1395 |
curIter = curSet.fastIterator(); |
1396 |
|
1397 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1398 |
orgIter.dispose(); |
1399 |
curIter.dispose(); |
1400 |
|
1401 |
orgIter = orgSet.iterator(); |
1402 |
curIter = curSet.fastIterator(); |
1403 |
|
1404 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1405 |
orgIter.dispose(); |
1406 |
curIter.dispose(); |
1407 |
|
1408 |
orgIter = orgSet.fastIterator(); |
1409 |
curIter = curSet.iterator(); |
1410 |
|
1411 |
assertTrue(compareFeatureIterators(orgIter, curIter, orgAttNames)); |
1412 |
orgIter.dispose(); |
1413 |
curIter.dispose(); |
1414 |
|
1415 |
curIter = curSet.iterator(); |
1416 |
while (curIter.hasNext()) {
|
1417 |
feature = (Feature) curIter.next(); |
1418 |
assertEquals("HOLA", feature.get("__ATTR1__")); |
1419 |
} |
1420 |
curIter.dispose(); |
1421 |
curSet.dispose(); |
1422 |
|
1423 |
query = this.getDefaultQuery(result);
|
1424 |
query.setAttributeNames(new String[] { "__ATTR1__" }); |
1425 |
curSet = result.getFeatureSet(query); |
1426 |
|
1427 |
assertEquals(1 + pkAttributesCount, curSet.getDefaultFeatureType()
|
1428 |
.size()); |
1429 |
|
1430 |
assertEquals(orgSet.getSize(), curSet.getSize()); |
1431 |
curIter = curSet.iterator(); |
1432 |
while (curIter.hasNext()) {
|
1433 |
feature = (Feature) curIter.next(); |
1434 |
assertEquals("HOLA", feature.get("__ATTR1__")); |
1435 |
} |
1436 |
curIter.dispose(); |
1437 |
curSet.dispose(); |
1438 |
|
1439 |
orgSet.dispose(); |
1440 |
result.dispose(); |
1441 |
this.clearCopy(store, newParams);
|
1442 |
store.dispose(); |
1443 |
|
1444 |
|
1445 |
} |
1446 |
|
1447 |
public void testResourcesLocks() throws Exception { |
1448 |
|
1449 |
|
1450 |
} |
1451 |
|
1452 |
} |