svn-gvsig-desktop / branches / v2_0_0_prep / libraries / libFMap_dataFile / src-test / org / gvsig / fmap / data / feature / file / DataStoreTest.java @ 23602
History | View | Annotate | Download (44.2 KB)
1 | 22373 | jmvivo | package org.gvsig.fmap.data.feature.file; |
---|---|---|---|
2 | 19401 | vcaballero | |
3 | import java.io.File; |
||
4 | 19468 | jmvivo | import java.util.Iterator; |
5 | 19401 | vcaballero | |
6 | 19402 | vcaballero | import junit.framework.TestCase; |
7 | |||
8 | 19603 | vcaballero | import org.cresques.cts.IProjection; |
9 | 21177 | vcaballero | import org.gvsig.fmap.crs.CRSFactory; |
10 | 21911 | jmvivo | import org.gvsig.fmap.data.CloseException; |
11 | import org.gvsig.fmap.data.DataCollection; |
||
12 | import org.gvsig.fmap.data.DataException; |
||
13 | import org.gvsig.fmap.data.DataManager; |
||
14 | 23543 | jmvivo | import org.gvsig.fmap.data.DataParameters; |
15 | 21911 | jmvivo | import org.gvsig.fmap.data.DataStoreParameters; |
16 | import org.gvsig.fmap.data.InitializeException; |
||
17 | import org.gvsig.fmap.data.OpenException; |
||
18 | import org.gvsig.fmap.data.ReadException; |
||
19 | import org.gvsig.fmap.data.Resource; |
||
20 | import org.gvsig.fmap.data.ResourceManager; |
||
21 | import org.gvsig.fmap.data.WriteException; |
||
22 | 22360 | jmvivo | import org.gvsig.fmap.data.feature.AbstractFeatureStore; |
23 | import org.gvsig.fmap.data.feature.AttributeDescriptor; |
||
24 | import org.gvsig.fmap.data.feature.Feature; |
||
25 | import org.gvsig.fmap.data.feature.FeatureAttributeDescriptor; |
||
26 | import org.gvsig.fmap.data.feature.FeatureCollection; |
||
27 | import org.gvsig.fmap.data.feature.FeatureStore; |
||
28 | import org.gvsig.fmap.data.feature.FeatureType; |
||
29 | import org.gvsig.fmap.data.feature.MemoryFeature; |
||
30 | 22373 | jmvivo | import org.gvsig.fmap.data.feature.file.dbf.DBFStore; |
31 | import org.gvsig.fmap.data.feature.file.dbf.DBFStoreParameters; |
||
32 | import org.gvsig.fmap.data.feature.file.dgn.DGNStore; |
||
33 | import org.gvsig.fmap.data.feature.file.dgn.DGNStoreParameters; |
||
34 | import org.gvsig.fmap.data.feature.file.dxf.DXFStore; |
||
35 | import org.gvsig.fmap.data.feature.file.dxf.DXFStoreParameters; |
||
36 | import org.gvsig.fmap.data.feature.file.shp.SHPStore; |
||
37 | import org.gvsig.fmap.data.feature.file.shp.SHPStoreParameters; |
||
38 | 22360 | jmvivo | import org.gvsig.fmap.data.feature.visitor.PrintlnFeaturesVisitor; |
39 | 23010 | jmvivo | import org.gvsig.fmap.geom.Geometry; |
40 | import org.gvsig.fmap.geom.handler.Handler; |
||
41 | 23303 | jmvivo | import org.gvsig.tools.exception.BaseException; |
42 | 23066 | jmvivo | import org.gvsig.tools.observer.Observer; |
43 | 19401 | vcaballero | |
44 | 23010 | jmvivo | import com.iver.utiles.XMLEntity; |
45 | 23181 | vcaballero | import com.iver.utiles.XMLException; |
46 | 23010 | jmvivo | |
47 | 19401 | vcaballero | public class DataStoreTest extends TestCase { |
48 | |||
49 | 23010 | jmvivo | private File dbffile = new File(DataStoreTest.class.getResource( |
50 | "data/prueba.dbf").getFile());
|
||
51 | private File shpfile = new File(DataStoreTest.class.getResource( |
||
52 | "data/prueba.shp").getFile());
|
||
53 | private File dxffile = new File(DataStoreTest.class.getResource( |
||
54 | "data/prueba.dxf").getFile());
|
||
55 | private File dgnfile = new File(DataStoreTest.class.getResource( |
||
56 | "data/prueba.dgn").getFile());
|
||
57 | 19401 | vcaballero | |
58 | public static void main(String[] args) { |
||
59 | junit.textui.TestRunner.run(DataStoreTest.class); |
||
60 | } |
||
61 | |||
62 | protected void setUp() throws Exception { |
||
63 | super.setUp();
|
||
64 | |||
65 | } |
||
66 | |||
67 | public void testDBF() { |
||
68 | 19658 | vcaballero | try {
|
69 | 20579 | jmvivo | System.out.println("======= DBF =============="); |
70 | 22373 | jmvivo | org.gvsig.fmap.data.feature.file.dbf.Register.selfRegister(); |
71 | 19401 | vcaballero | |
72 | 23010 | jmvivo | DataManager dsm = DataManager.getManager(); |
73 | 19401 | vcaballero | |
74 | 23010 | jmvivo | DataStoreParameters dp = dsm |
75 | .createDataStoreParameters(DBFStore.DATASTORE_NAME); |
||
76 | ((DBFStoreParameters) dp).setFile(dbffile); |
||
77 | 19401 | vcaballero | |
78 | 23010 | jmvivo | driverTest(dp, null, null, true); |
79 | FeatureStore fs = null;
|
||
80 | 20579 | jmvivo | try {
|
81 | 23010 | jmvivo | fs = (FeatureStore) dsm.createDataStore(dp); |
82 | 20579 | jmvivo | } catch (InitializeException e) {
|
83 | e.printStackTrace(); |
||
84 | fail("Exception:" + e);
|
||
85 | } |
||
86 | assertNotNull("Can't create Feature Store", fs);
|
||
87 | 19468 | jmvivo | |
88 | 23010 | jmvivo | // fs.open();
|
89 | 19658 | vcaballero | |
90 | 20579 | jmvivo | Iterator it;
|
91 | 21045 | jmvivo | FeatureCollection fc; |
92 | 23010 | jmvivo | Comparable v1, v2;
|
93 | Feature feature, pfeature; |
||
94 | 20579 | jmvivo | long count;
|
95 | 19468 | jmvivo | |
96 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
97 | 19468 | jmvivo | |
98 | 20579 | jmvivo | assertEquals(9, fc.size());
|
99 | 19468 | jmvivo | |
100 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
101 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'", null); |
||
102 | 19468 | jmvivo | |
103 | 20579 | jmvivo | assertEquals(2, fc.size());
|
104 | 19468 | jmvivo | |
105 | 20579 | jmvivo | it = fc.iterator(); |
106 | 23010 | jmvivo | count = 0;
|
107 | while (it.hasNext()) {
|
||
108 | feature = (Feature) it.next(); |
||
109 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
110 | .toLowerCase().startsWith("b"));
|
||
111 | 20579 | jmvivo | count++; |
112 | } |
||
113 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
114 | 19468 | jmvivo | |
115 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
116 | .getDefaultFeatureType(), null, "NOMBRE ASC"); |
||
117 | 20579 | jmvivo | assertEquals(9, fc.size());
|
118 | it = fc.iterator(); |
||
119 | 23010 | jmvivo | count = 0;
|
120 | pfeature = (Feature) it.next(); |
||
121 | 19470 | jmvivo | count++; |
122 | 23010 | jmvivo | while (it.hasNext()) {
|
123 | feature = (Feature) it.next(); |
||
124 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
125 | v2 = (Comparable) feature.get("NOMBRE"); |
||
126 | pfeature = feature; |
||
127 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
128 | count++; |
||
129 | } |
||
130 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
131 | 19468 | jmvivo | |
132 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
133 | .getDefaultFeatureType(), null, "NOMBRE DESC"); |
||
134 | 20579 | jmvivo | assertEquals(9, fc.size());
|
135 | it = fc.iterator(); |
||
136 | 19468 | jmvivo | |
137 | 23010 | jmvivo | count = 0;
|
138 | pfeature = (Feature) it.next(); |
||
139 | 19470 | jmvivo | count++; |
140 | 23010 | jmvivo | while (it.hasNext()) {
|
141 | feature = (Feature) it.next(); |
||
142 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
143 | v2 = (Comparable) feature.get("NOMBRE"); |
||
144 | pfeature = feature; |
||
145 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) >= 0)); |
146 | count++; |
||
147 | } |
||
148 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
149 | 19468 | jmvivo | |
150 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
151 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'",
|
||
152 | "NOMBRE");
|
||
153 | 19468 | jmvivo | |
154 | 20579 | jmvivo | assertEquals(2, fc.size());
|
155 | 19468 | jmvivo | |
156 | 20579 | jmvivo | it = fc.iterator(); |
157 | 19468 | jmvivo | |
158 | 23010 | jmvivo | count = 0;
|
159 | pfeature = (Feature) it.next(); |
||
160 | assertTrue(pfeature.getString("NOMBRE").toLowerCase().startsWith(
|
||
161 | "b"));
|
||
162 | 19470 | jmvivo | count++; |
163 | 23010 | jmvivo | while (it.hasNext()) {
|
164 | feature = (Feature) it.next(); |
||
165 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
166 | .toLowerCase().startsWith("b"));
|
||
167 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
168 | v2 = (Comparable) feature.get("NOMBRE"); |
||
169 | pfeature = feature; |
||
170 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
171 | count++; |
||
172 | } |
||
173 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
174 | 19468 | jmvivo | |
175 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
176 | .getDefaultFeatureType(), null, "Tipo,lower(NOMBRE) Desc"); |
||
177 | 20579 | jmvivo | assertEquals(9, fc.size());
|
178 | it = fc.iterator(); |
||
179 | 23010 | jmvivo | count = 0;
|
180 | pfeature = (Feature) it.next(); |
||
181 | 19480 | jmvivo | System.out.println(pfeature.getString("NOMBRE")); |
182 | count++; |
||
183 | 23010 | jmvivo | while (it.hasNext()) {
|
184 | feature = (Feature) it.next(); |
||
185 | v1 = ((String) pfeature.get("NOMBRE")).toLowerCase(); |
||
186 | v2 = ((String) feature.get("NOMBRE")).toLowerCase(); |
||
187 | pfeature = feature; |
||
188 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
189 | System.out.println(pfeature.getString("NOMBRE")); |
||
190 | count++; |
||
191 | } |
||
192 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
193 | 19480 | jmvivo | |
194 | 20579 | jmvivo | /// CON EDICION
|
195 | 19664 | jmvivo | |
196 | 20579 | jmvivo | fs.startEditing(); |
197 | 19664 | jmvivo | |
198 | 21069 | jmvivo | Feature newFeature = fs.createDefaultFeature(true);
|
199 | 20579 | jmvivo | newFeature.editing(); |
200 | 23010 | jmvivo | newFeature.set("NOMBRE", "BuRjaSOT"); |
201 | newFeature.set("TIPO", "MUNICIPIO"); |
||
202 | 20579 | jmvivo | fs.insert(newFeature); |
203 | 19664 | jmvivo | |
204 | 20579 | jmvivo | try {
|
205 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
206 | 20579 | jmvivo | } catch (ReadException e1) {
|
207 | e1.printStackTrace(); |
||
208 | fail(); |
||
209 | } |
||
210 | 19664 | jmvivo | |
211 | 20579 | jmvivo | assertEquals(10, fc.size());
|
212 | 19664 | jmvivo | |
213 | 20579 | jmvivo | try {
|
214 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
215 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'",
|
||
216 | null);
|
||
217 | 20579 | jmvivo | } catch (ReadException e1) {
|
218 | e1.printStackTrace(); |
||
219 | fail(); |
||
220 | } |
||
221 | 19664 | jmvivo | |
222 | 20579 | jmvivo | assertEquals(3, fc.size());
|
223 | 19664 | jmvivo | |
224 | 20579 | jmvivo | it = fc.iterator(); |
225 | 23010 | jmvivo | count = 0;
|
226 | while (it.hasNext()) {
|
||
227 | feature = (Feature) it.next(); |
||
228 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
229 | .toLowerCase().startsWith("b"));
|
||
230 | 20579 | jmvivo | count++; |
231 | } |
||
232 | 23010 | jmvivo | assertEquals("Iteration error", 3, count); |
233 | 19664 | jmvivo | |
234 | 20579 | jmvivo | try {
|
235 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
236 | .getDefaultFeatureType(), null, "NOMBRE ASC"); |
||
237 | 20579 | jmvivo | } catch (ReadException e1) {
|
238 | e1.printStackTrace(); |
||
239 | fail(); |
||
240 | } |
||
241 | assertEquals(10, fc.size());
|
||
242 | it = fc.iterator(); |
||
243 | 23010 | jmvivo | count = 0;
|
244 | pfeature = (Feature) it.next(); |
||
245 | 19664 | jmvivo | count++; |
246 | 23010 | jmvivo | while (it.hasNext()) {
|
247 | feature = (Feature) it.next(); |
||
248 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
249 | v2 = (Comparable) feature.get("NOMBRE"); |
||
250 | pfeature = feature; |
||
251 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
252 | count++; |
||
253 | } |
||
254 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
255 | 19664 | jmvivo | |
256 | 20579 | jmvivo | try {
|
257 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
258 | .getDefaultFeatureType(), null, "NOMBRE DESC"); |
||
259 | 20579 | jmvivo | } catch (ReadException e1) {
|
260 | e1.printStackTrace(); |
||
261 | fail(); |
||
262 | } |
||
263 | 21177 | vcaballero | assertEquals(10, fc.size());
|
264 | 20579 | jmvivo | it = fc.iterator(); |
265 | 19664 | jmvivo | |
266 | 23010 | jmvivo | count = 0;
|
267 | pfeature = (Feature) it.next(); |
||
268 | 19664 | jmvivo | count++; |
269 | 23010 | jmvivo | while (it.hasNext()) {
|
270 | feature = (Feature) it.next(); |
||
271 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
272 | v2 = (Comparable) feature.get("NOMBRE"); |
||
273 | pfeature = feature; |
||
274 | if (v1 != null && v2 != null) { |
||
275 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) >= 0)); |
276 | 23010 | jmvivo | } |
277 | 20579 | jmvivo | count++; |
278 | } |
||
279 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
280 | 19664 | jmvivo | |
281 | 20579 | jmvivo | try {
|
282 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection( |
283 | new String[] { "NOMBRE" }, "lower(NOMBRE) like 'b%'", |
||
284 | "NOMBRE");
|
||
285 | 20579 | jmvivo | } catch (ReadException e1) {
|
286 | e1.printStackTrace(); |
||
287 | fail(); |
||
288 | } |
||
289 | 19664 | jmvivo | |
290 | 20579 | jmvivo | assertEquals(3, fc.size());
|
291 | 19664 | jmvivo | |
292 | 20579 | jmvivo | it = fc.iterator(); |
293 | 19664 | jmvivo | |
294 | 23010 | jmvivo | count = 0;
|
295 | pfeature = (Feature) it.next(); |
||
296 | assertTrue(pfeature.getString("NOMBRE").toLowerCase().startsWith(
|
||
297 | "b"));
|
||
298 | 19664 | jmvivo | count++; |
299 | 23010 | jmvivo | while (it.hasNext()) {
|
300 | feature = (Feature) it.next(); |
||
301 | if (!(feature instanceof MemoryFeature)) { //FIXME OJO con los featureType de los Feature en memoria |
||
302 | 21120 | jmvivo | assertEquals(1, feature.getType().size());
|
303 | } |
||
304 | 23010 | jmvivo | assertTrue("Filter error", feature.getString("NOMBRE") |
305 | .toLowerCase().startsWith("b"));
|
||
306 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
307 | v2 = (Comparable) feature.get("NOMBRE"); |
||
308 | pfeature = feature; |
||
309 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
310 | count++; |
||
311 | } |
||
312 | 23010 | jmvivo | assertEquals("Iteration error", 3, count); |
313 | 19664 | jmvivo | |
314 | 20579 | jmvivo | try {
|
315 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
316 | .getDefaultFeatureType(), null,
|
||
317 | "Tipo,lower(NOMBRE) Desc");
|
||
318 | 20579 | jmvivo | } catch (ReadException e1) {
|
319 | e1.printStackTrace(); |
||
320 | fail(); |
||
321 | 20480 | jmvivo | } |
322 | 20579 | jmvivo | assertEquals(10, fc.size());
|
323 | it = fc.iterator(); |
||
324 | 23010 | jmvivo | count = 0;
|
325 | pfeature = (Feature) it.next(); |
||
326 | System.out.println(pfeature.getString("TIPO") + "," |
||
327 | + pfeature.getString("NOMBRE"));
|
||
328 | 19664 | jmvivo | count++; |
329 | 23010 | jmvivo | while (it.hasNext()) {
|
330 | feature = (Feature) it.next(); |
||
331 | System.out.println(feature.getString("TIPO") + "," |
||
332 | + feature.getString("NOMBRE"));
|
||
333 | v1 = ((String) pfeature.get("TIPO")).toLowerCase(); |
||
334 | v2 = ((String) feature.get("TIPO")).toLowerCase(); |
||
335 | 20579 | jmvivo | assertTrue("Short error", (v2.compareTo(v1) >= 0)); |
336 | 23010 | jmvivo | if (v1.compareTo(v2) == 0) { |
337 | v1 = ((String) pfeature.get("NOMBRE")).toLowerCase(); |
||
338 | v2 = ((String) feature.get("NOMBRE")).toLowerCase(); |
||
339 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
340 | } |
||
341 | 23010 | jmvivo | pfeature = feature; |
342 | 19664 | jmvivo | |
343 | 23010 | jmvivo | // System.out.println(pfeature.getString("TIPO")+","+pfeature.getString("NOMBRE"));
|
344 | 20579 | jmvivo | count++; |
345 | } |
||
346 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
347 | 19664 | jmvivo | |
348 | 20579 | jmvivo | fs.cancelEditing(); |
349 | 19468 | jmvivo | |
350 | 23010 | jmvivo | // try {
|
351 | // fs.close();
|
||
352 | // } catch (CloseException e) {
|
||
353 | // e.printStackTrace();
|
||
354 | // fail("Exception:" + e);
|
||
355 | // }
|
||
356 | 19468 | jmvivo | |
357 | 20579 | jmvivo | System.out.println("======= /DBF =============="); |
358 | |||
359 | } catch (DataException e) {
|
||
360 | 19658 | vcaballero | e.printStackTrace(); |
361 | 23010 | jmvivo | fail(); |
362 | 19658 | vcaballero | } |
363 | 23010 | jmvivo | |
364 | 19449 | jmvivo | } |
365 | |||
366 | public void testSHP() { |
||
367 | 19658 | vcaballero | try {
|
368 | 20579 | jmvivo | System.out.println("======= SHP =============="); |
369 | 22373 | jmvivo | org.gvsig.fmap.data.feature.file.shp.Register.selfRegister(); |
370 | org.gvsig.fmap.data.feature.file.dbf.Register.selfRegister(); |
||
371 | 19449 | jmvivo | |
372 | 23010 | jmvivo | DataManager dsm = DataManager.getManager(); |
373 | 19449 | jmvivo | |
374 | 23010 | jmvivo | DataStoreParameters dp = dsm |
375 | .createDataStoreParameters(SHPStore.DATASTORE_NAME); |
||
376 | ((SHPStoreParameters) dp).setFile(shpfile); |
||
377 | // ((SHPStoreParameters)dp).setSHXFile(SHP.getShxFile(shpfile));
|
||
378 | // ((SHPStoreParameters)dp).setDBFFile(SHP.getDbfFile(shpfile));
|
||
379 | 19449 | jmvivo | |
380 | 23010 | jmvivo | driverTest(dp, null, null, true); |
381 | 19449 | jmvivo | |
382 | 23010 | jmvivo | FeatureStore fs = null;
|
383 | 20579 | jmvivo | try {
|
384 | 23010 | jmvivo | fs = (FeatureStore) dsm.createDataStore(dp); |
385 | 20579 | jmvivo | } catch (InitializeException e) {
|
386 | e.printStackTrace(); |
||
387 | fail("Exception:" + e);
|
||
388 | } |
||
389 | 19468 | jmvivo | |
390 | 20579 | jmvivo | assertNotNull("Can't create Feature Store", fs);
|
391 | 19480 | jmvivo | |
392 | 23010 | jmvivo | // fs.open();
|
393 | 19658 | vcaballero | |
394 | 20579 | jmvivo | Iterator it;
|
395 | 21045 | jmvivo | FeatureCollection fc; |
396 | 23010 | jmvivo | Comparable v1, v2;
|
397 | Feature feature, pfeature; |
||
398 | 20579 | jmvivo | long count;
|
399 | 19480 | jmvivo | |
400 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
401 | 19480 | jmvivo | |
402 | 20579 | jmvivo | assertEquals(9, fc.size());
|
403 | 19480 | jmvivo | |
404 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
405 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'", null); |
||
406 | 19480 | jmvivo | |
407 | 20579 | jmvivo | assertEquals(2, fc.size());
|
408 | 19480 | jmvivo | |
409 | 20579 | jmvivo | it = fc.iterator(); |
410 | 23010 | jmvivo | count = 0;
|
411 | while (it.hasNext()) {
|
||
412 | feature = (Feature) it.next(); |
||
413 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
414 | .toLowerCase().startsWith("b"));
|
||
415 | 20579 | jmvivo | count++; |
416 | } |
||
417 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
418 | 19480 | jmvivo | |
419 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
420 | .getDefaultFeatureType(), null, "NOMBRE"); |
||
421 | 20579 | jmvivo | assertEquals(9, fc.size());
|
422 | it = fc.iterator(); |
||
423 | 23010 | jmvivo | count = 0;
|
424 | pfeature = (Feature) it.next(); |
||
425 | 19480 | jmvivo | count++; |
426 | 23010 | jmvivo | while (it.hasNext()) {
|
427 | feature = (Feature) it.next(); |
||
428 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
429 | v2 = (Comparable) feature.get("NOMBRE"); |
||
430 | pfeature = feature; |
||
431 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) <= 0)); |
432 | count++; |
||
433 | } |
||
434 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
435 | 19480 | jmvivo | |
436 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
437 | .getDefaultFeatureType(), null, "NOMBRE DESC"); |
||
438 | 20579 | jmvivo | assertEquals(9, fc.size());
|
439 | it = fc.iterator(); |
||
440 | 23010 | jmvivo | count = 0;
|
441 | pfeature = (Feature) it.next(); |
||
442 | 19480 | jmvivo | System.out.println(pfeature.getString("NOMBRE")); |
443 | count++; |
||
444 | 23010 | jmvivo | while (it.hasNext()) {
|
445 | feature = (Feature) it.next(); |
||
446 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
447 | v2 = (Comparable) feature.get("NOMBRE"); |
||
448 | pfeature = feature; |
||
449 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
450 | System.out.println(pfeature.getString("NOMBRE")); |
||
451 | count++; |
||
452 | } |
||
453 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
454 | 19480 | jmvivo | |
455 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
456 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'",
|
||
457 | "NOMBRE ASC");
|
||
458 | 19480 | jmvivo | |
459 | 20579 | jmvivo | assertEquals(2, fc.size());
|
460 | 19480 | jmvivo | |
461 | 20579 | jmvivo | it = fc.iterator(); |
462 | 19480 | jmvivo | |
463 | 23010 | jmvivo | count = 0;
|
464 | pfeature = (Feature) it.next(); |
||
465 | assertTrue(pfeature.getString("NOMBRE").toLowerCase().startsWith(
|
||
466 | "b"));
|
||
467 | 19480 | jmvivo | count++; |
468 | 23010 | jmvivo | while (it.hasNext()) {
|
469 | feature = (Feature) it.next(); |
||
470 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
471 | .toLowerCase().startsWith("b"));
|
||
472 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
473 | v2 = (Comparable) feature.get("NOMBRE"); |
||
474 | pfeature = feature; |
||
475 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) <= 0)); |
476 | count++; |
||
477 | } |
||
478 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
479 | 19480 | jmvivo | |
480 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
481 | .getDefaultFeatureType(), null, "lower(NOMBRE) ASC"); |
||
482 | 20579 | jmvivo | assertEquals(9, fc.size());
|
483 | it = fc.iterator(); |
||
484 | 23010 | jmvivo | count = 0;
|
485 | pfeature = (Feature) it.next(); |
||
486 | 19480 | jmvivo | count++; |
487 | 23010 | jmvivo | while (it.hasNext()) {
|
488 | feature = (Feature) it.next(); |
||
489 | v1 = ((String) pfeature.get("NOMBRE")).toLowerCase(); |
||
490 | v2 = ((String) feature.get("NOMBRE")).toLowerCase(); |
||
491 | pfeature = feature; |
||
492 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) <= 0)); |
493 | count++; |
||
494 | } |
||
495 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
496 | 19480 | jmvivo | |
497 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
498 | .getDefaultFeatureType(), null, "Tipo,lower(NOMBRE) Desc"); |
||
499 | 20579 | jmvivo | assertEquals(9, fc.size());
|
500 | it = fc.iterator(); |
||
501 | 23010 | jmvivo | count = 0;
|
502 | pfeature = (Feature) it.next(); |
||
503 | 19480 | jmvivo | System.out.println(pfeature.getString("NOMBRE")); |
504 | count++; |
||
505 | 23010 | jmvivo | while (it.hasNext()) {
|
506 | feature = (Feature) it.next(); |
||
507 | v1 = ((String) pfeature.get("NOMBRE")).toLowerCase(); |
||
508 | v2 = ((String) feature.get("NOMBRE")).toLowerCase(); |
||
509 | pfeature = feature; |
||
510 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
511 | System.out.println(pfeature.getString("NOMBRE")); |
||
512 | count++; |
||
513 | } |
||
514 | 23010 | jmvivo | assertEquals("Iteration error", 9, count); |
515 | 19480 | jmvivo | |
516 | 20579 | jmvivo | /// CON EDICION
|
517 | 19664 | jmvivo | |
518 | 20579 | jmvivo | fs.startEditing(); |
519 | 19664 | jmvivo | |
520 | 21069 | jmvivo | Feature newFeature = fs.createDefaultFeature(true);
|
521 | 20579 | jmvivo | newFeature.editing(); |
522 | 23010 | jmvivo | newFeature.set("NOMBRE", "BuRjaSOT"); |
523 | newFeature.set("TIPO", "MUNICIPIO"); |
||
524 | 20579 | jmvivo | fs.insert(newFeature); |
525 | 19664 | jmvivo | |
526 | 20579 | jmvivo | try {
|
527 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
528 | 20579 | jmvivo | } catch (ReadException e1) {
|
529 | e1.printStackTrace(); |
||
530 | fail(); |
||
531 | } |
||
532 | 19664 | jmvivo | |
533 | 20579 | jmvivo | assertEquals(10, fc.size());
|
534 | 19664 | jmvivo | |
535 | 20579 | jmvivo | try {
|
536 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
537 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'",
|
||
538 | null);
|
||
539 | 20579 | jmvivo | } catch (ReadException e1) {
|
540 | e1.printStackTrace(); |
||
541 | fail(); |
||
542 | } |
||
543 | 19664 | jmvivo | |
544 | 20579 | jmvivo | assertEquals(3, fc.size());
|
545 | 19664 | jmvivo | |
546 | 20579 | jmvivo | it = fc.iterator(); |
547 | 23010 | jmvivo | count = 0;
|
548 | while (it.hasNext()) {
|
||
549 | feature = (Feature) it.next(); |
||
550 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
551 | .toLowerCase().startsWith("b"));
|
||
552 | 20579 | jmvivo | count++; |
553 | } |
||
554 | 23010 | jmvivo | assertEquals("Iteration error", 3, count); |
555 | 19664 | jmvivo | |
556 | 20579 | jmvivo | try {
|
557 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
558 | .getDefaultFeatureType(), null, "NOMBRE ASC"); |
||
559 | 20579 | jmvivo | } catch (ReadException e1) {
|
560 | e1.printStackTrace(); |
||
561 | fail(); |
||
562 | } |
||
563 | assertEquals(10, fc.size());
|
||
564 | it = fc.iterator(); |
||
565 | 23010 | jmvivo | count = 0;
|
566 | pfeature = (Feature) it.next(); |
||
567 | 19664 | jmvivo | count++; |
568 | 23010 | jmvivo | while (it.hasNext()) {
|
569 | feature = (Feature) it.next(); |
||
570 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
571 | v2 = (Comparable) feature.get("NOMBRE"); |
||
572 | pfeature = feature; |
||
573 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
574 | count++; |
||
575 | } |
||
576 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
577 | 19664 | jmvivo | |
578 | 20579 | jmvivo | try {
|
579 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
580 | .getDefaultFeatureType(), null, "NOMBRE DESC"); |
||
581 | 20579 | jmvivo | } catch (ReadException e1) {
|
582 | e1.printStackTrace(); |
||
583 | fail(); |
||
584 | } |
||
585 | assertEquals(10, fc.size());
|
||
586 | it = fc.iterator(); |
||
587 | 19664 | jmvivo | |
588 | 23010 | jmvivo | count = 0;
|
589 | pfeature = (Feature) it.next(); |
||
590 | 19664 | jmvivo | count++; |
591 | 23010 | jmvivo | while (it.hasNext()) {
|
592 | feature = (Feature) it.next(); |
||
593 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
594 | v2 = (Comparable) feature.get("NOMBRE"); |
||
595 | pfeature = feature; |
||
596 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) >= 0)); |
597 | count++; |
||
598 | } |
||
599 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
600 | 19664 | jmvivo | |
601 | 20579 | jmvivo | try {
|
602 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
603 | .getDefaultFeatureType(), "lower(NOMBRE) like 'b%'",
|
||
604 | "NOMBRE");
|
||
605 | 20579 | jmvivo | } catch (ReadException e1) {
|
606 | e1.printStackTrace(); |
||
607 | fail(); |
||
608 | } |
||
609 | 19664 | jmvivo | |
610 | 20579 | jmvivo | assertEquals(3, fc.size());
|
611 | 19664 | jmvivo | |
612 | 20579 | jmvivo | it = fc.iterator(); |
613 | 19664 | jmvivo | |
614 | 23010 | jmvivo | count = 0;
|
615 | pfeature = (Feature) it.next(); |
||
616 | assertTrue(pfeature.getString("NOMBRE").toLowerCase().startsWith(
|
||
617 | "b"));
|
||
618 | 19664 | jmvivo | count++; |
619 | 23010 | jmvivo | while (it.hasNext()) {
|
620 | feature = (Feature) it.next(); |
||
621 | assertTrue("Filter error", feature.getString("NOMBRE") |
||
622 | .toLowerCase().startsWith("b"));
|
||
623 | v1 = (Comparable) pfeature.get("NOMBRE"); |
||
624 | v2 = (Comparable) feature.get("NOMBRE"); |
||
625 | pfeature = feature; |
||
626 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
627 | count++; |
||
628 | } |
||
629 | 23010 | jmvivo | assertEquals("Iteration error", 3, count); |
630 | 19664 | jmvivo | |
631 | 20579 | jmvivo | try {
|
632 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
633 | .getDefaultFeatureType(), null,
|
||
634 | "Tipo,lower(NOMBRE) Desc");
|
||
635 | 20579 | jmvivo | } catch (ReadException e1) {
|
636 | e1.printStackTrace(); |
||
637 | fail(); |
||
638 | } |
||
639 | assertEquals(10, fc.size());
|
||
640 | it = fc.iterator(); |
||
641 | 23010 | jmvivo | count = 0;
|
642 | pfeature = (Feature) it.next(); |
||
643 | 19664 | jmvivo | System.out.println(pfeature.getString("NOMBRE")); |
644 | count++; |
||
645 | 23010 | jmvivo | while (it.hasNext()) {
|
646 | feature = (Feature) it.next(); |
||
647 | v1 = ((String) pfeature.get("NOMBRE")).toLowerCase(); |
||
648 | v2 = ((String) feature.get("NOMBRE")).toLowerCase(); |
||
649 | pfeature = feature; |
||
650 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
651 | System.out.println(pfeature.getString("NOMBRE")); |
||
652 | count++; |
||
653 | } |
||
654 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
655 | 19664 | jmvivo | |
656 | 20579 | jmvivo | fs.cancelEditing(); |
657 | 19664 | jmvivo | |
658 | 23010 | jmvivo | // try {
|
659 | // fs.close();
|
||
660 | // } catch (CloseException e) {
|
||
661 | // e.printStackTrace();
|
||
662 | // fail("Exception:" + e);
|
||
663 | // }
|
||
664 | 19664 | jmvivo | |
665 | 20579 | jmvivo | System.out.println("======= /SHP =============="); |
666 | } catch (DataException e) {
|
||
667 | 19658 | vcaballero | // TODO Auto-generated catch block
|
668 | e.printStackTrace(); |
||
669 | } |
||
670 | 19449 | jmvivo | } |
671 | |||
672 | 19603 | vcaballero | public void testDXF() { |
673 | 19658 | vcaballero | try {
|
674 | 20579 | jmvivo | System.out.println("======= DXF =============="); |
675 | 22373 | jmvivo | org.gvsig.fmap.data.feature.file.dxf.Register.selfRegister(); |
676 | 19603 | vcaballero | |
677 | 23010 | jmvivo | DataManager dsm = DataManager.getManager(); |
678 | 19603 | vcaballero | |
679 | 23010 | jmvivo | DataStoreParameters dp = dsm |
680 | .createDataStoreParameters(DXFStore.DATASTORE_NAME); |
||
681 | ((DXFStoreParameters) dp).setFile(dxffile); |
||
682 | 21045 | jmvivo | IProjection proj = CRSFactory.getCRS("EPSG:23030");
|
683 | 23010 | jmvivo | ((DXFStoreParameters) dp).setSRSID("EPSG:23030");
|
684 | driverTest(dp, null, null, true); |
||
685 | 19603 | vcaballero | |
686 | 23010 | jmvivo | FeatureStore fs = null;
|
687 | 20579 | jmvivo | try {
|
688 | 23010 | jmvivo | fs = (FeatureStore) dsm.createDataStore(dp); |
689 | 20579 | jmvivo | } catch (InitializeException e) {
|
690 | e.printStackTrace(); |
||
691 | fail("Exception:" + e);
|
||
692 | } |
||
693 | assertNotNull("Can't create Feature Store", fs);
|
||
694 | 19603 | vcaballero | |
695 | 23010 | jmvivo | // fs.open();
|
696 | 19658 | vcaballero | |
697 | 20579 | jmvivo | Iterator it;
|
698 | 21045 | jmvivo | FeatureCollection fc; |
699 | 23010 | jmvivo | Comparable v1, v2;
|
700 | Feature feature, pfeature; |
||
701 | 20579 | jmvivo | long count;
|
702 | 19603 | vcaballero | |
703 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
704 | 19603 | vcaballero | |
705 | 20579 | jmvivo | assertEquals(10, fc.size());
|
706 | 19603 | vcaballero | |
707 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
708 | .getDefaultFeatureType(), "Color > '7'", null); |
||
709 | 19603 | vcaballero | |
710 | 20579 | jmvivo | assertEquals(2, fc.size());
|
711 | 19603 | vcaballero | |
712 | 20579 | jmvivo | it = fc.iterator(); |
713 | 23010 | jmvivo | count = 0;
|
714 | while (it.hasNext()) {
|
||
715 | feature = (Feature) it.next(); |
||
716 | assertTrue("Filter error", feature.getInt("Color") > 7); |
||
717 | 20579 | jmvivo | count++; |
718 | } |
||
719 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
720 | 19603 | vcaballero | |
721 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
722 | .getDefaultFeatureType(), null, "Layer ASC"); |
||
723 | 20579 | jmvivo | assertEquals(10, fc.size());
|
724 | it = fc.iterator(); |
||
725 | 23010 | jmvivo | count = 0;
|
726 | pfeature = (Feature) it.next(); |
||
727 | 19603 | vcaballero | count++; |
728 | 23010 | jmvivo | while (it.hasNext()) {
|
729 | feature = (Feature) it.next(); |
||
730 | v1 = (Comparable) pfeature.get("Layer"); |
||
731 | v2 = (Comparable) feature.get("Layer"); |
||
732 | pfeature = feature; |
||
733 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) <= 0)); |
734 | count++; |
||
735 | } |
||
736 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
737 | 19603 | vcaballero | |
738 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
739 | .getDefaultFeatureType(), null, "Layer DESC"); |
||
740 | 20579 | jmvivo | assertEquals(10, fc.size());
|
741 | it = fc.iterator(); |
||
742 | 19603 | vcaballero | |
743 | 23010 | jmvivo | count = 0;
|
744 | pfeature = (Feature) it.next(); |
||
745 | 19603 | vcaballero | count++; |
746 | 23010 | jmvivo | while (it.hasNext()) {
|
747 | feature = (Feature) it.next(); |
||
748 | v1 = (Comparable) pfeature.get("Layer"); |
||
749 | v2 = (Comparable) feature.get("Layer"); |
||
750 | pfeature = feature; |
||
751 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v1) >= 0)); |
752 | count++; |
||
753 | } |
||
754 | 23010 | jmvivo | assertEquals("Iteration error", 10, count); |
755 | 19603 | vcaballero | |
756 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
757 | .getDefaultFeatureType(), "Color > '7'", "Layer ASC"); |
||
758 | 19603 | vcaballero | |
759 | 20579 | jmvivo | assertEquals(2, fc.size());
|
760 | 19603 | vcaballero | |
761 | 20579 | jmvivo | it = fc.iterator(); |
762 | 19603 | vcaballero | |
763 | 23010 | jmvivo | count = 0;
|
764 | pfeature = (Feature) it.next(); |
||
765 | assertTrue(pfeature.getInt("Color") > 7); |
||
766 | 19603 | vcaballero | count++; |
767 | 23010 | jmvivo | while (it.hasNext()) {
|
768 | feature = (Feature) it.next(); |
||
769 | assertTrue("Filter error", feature.getInt("Color") > 7); |
||
770 | v1 = (Comparable) pfeature.get("Color"); |
||
771 | v2 = (Comparable) feature.get("Color"); |
||
772 | pfeature = feature; |
||
773 | Integer i1 = (Integer) v1; |
||
774 | Integer i2 = (Integer) v2; |
||
775 | assertTrue("Short error", (i1.intValue() > i2.intValue()));
|
||
776 | 20579 | jmvivo | count++; |
777 | } |
||
778 | 23010 | jmvivo | assertEquals("Iteration error", 2, count); |
779 | 19603 | vcaballero | |
780 | 23010 | jmvivo | // fc = (FeatureCollection)fs.getDataCollection(null,null,"Color,Layer Desc");
|
781 | // assertEquals(10, fc.size());
|
||
782 | // it = fc.iterator();
|
||
783 | // count=0;
|
||
784 | // pfeature = (Feature)it.next();
|
||
785 | // System.out.println(pfeature.getString("Layer"));
|
||
786 | // count++;
|
||
787 | // while (it.hasNext()){
|
||
788 | // feature = (Feature)it.next();
|
||
789 | // v1 = (Comparable)((String)pfeature.get("Layer")).toLowerCase();
|
||
790 | // v2 = (Comparable)((String)feature.get("Layer")).toLowerCase();
|
||
791 | // pfeature=feature;
|
||
792 | // assertTrue("Short error", (v1.compareTo(v2) >= 0));
|
||
793 | // System.out.println(pfeature.getString("Layer"));
|
||
794 | // count++;
|
||
795 | // }
|
||
796 | // assertEquals("Iteration error",10,count);
|
||
797 | 19603 | vcaballero | |
798 | 23010 | jmvivo | // try {
|
799 | // fs.close();
|
||
800 | // } catch (CloseException e) {
|
||
801 | // e.printStackTrace();
|
||
802 | // fail("Exception:" + e);
|
||
803 | // }
|
||
804 | 19603 | vcaballero | |
805 | 20579 | jmvivo | System.out.println("======= /DXF =============="); |
806 | 19658 | vcaballero | } catch (OpenException e1) {
|
807 | e1.printStackTrace(); |
||
808 | fail(); |
||
809 | } catch (ReadException e) {
|
||
810 | // TODO Auto-generated catch block
|
||
811 | e.printStackTrace(); |
||
812 | } |
||
813 | 19603 | vcaballero | } |
814 | |||
815 | 19654 | vcaballero | public void testDGN() { |
816 | 19658 | vcaballero | try {
|
817 | 20579 | jmvivo | System.out.println("======= DGN =============="); |
818 | 22373 | jmvivo | org.gvsig.fmap.data.feature.file.dgn.Register.selfRegister(); |
819 | 19603 | vcaballero | |
820 | 23010 | jmvivo | DataManager dsm = DataManager.getManager(); |
821 | 19603 | vcaballero | |
822 | 23010 | jmvivo | DataStoreParameters dp = dsm |
823 | .createDataStoreParameters(DGNStore.DATASTORE_NAME); |
||
824 | ((DGNStoreParameters) dp).setFile(dgnfile); |
||
825 | driverTest(dp, null, null, true); |
||
826 | FeatureStore fs = null;
|
||
827 | 20579 | jmvivo | try {
|
828 | 23010 | jmvivo | fs = (FeatureStore) dsm.createDataStore(dp); |
829 | 20579 | jmvivo | } catch (InitializeException e) {
|
830 | e.printStackTrace(); |
||
831 | fail("Exception:" + e);
|
||
832 | } |
||
833 | assertNotNull("Can't create Feature Store", fs);
|
||
834 | 19603 | vcaballero | |
835 | 23010 | jmvivo | // fs.open();
|
836 | 19658 | vcaballero | |
837 | 20579 | jmvivo | Iterator it;
|
838 | 21045 | jmvivo | FeatureCollection fc; |
839 | 23010 | jmvivo | Comparable v1, v2;
|
840 | Feature feature, pfeature; |
||
841 | 20579 | jmvivo | long count;
|
842 | 19654 | vcaballero | |
843 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(); |
844 | 19654 | vcaballero | |
845 | 20688 | jmvivo | assertEquals(57, fc.size());
|
846 | 19654 | vcaballero | |
847 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
848 | .getDefaultFeatureType(), "Color > '7'", null); |
||
849 | 19654 | vcaballero | |
850 | 20688 | jmvivo | assertEquals(45, fc.size());
|
851 | 19654 | vcaballero | |
852 | 20579 | jmvivo | it = fc.iterator(); |
853 | 23010 | jmvivo | count = 0;
|
854 | while (it.hasNext()) {
|
||
855 | feature = (Feature) it.next(); |
||
856 | assertTrue("Filter error", feature.getInt("Color") >= 7); |
||
857 | 20579 | jmvivo | count++; |
858 | } |
||
859 | 23010 | jmvivo | assertEquals("Iteration error", 45, count); |
860 | 19654 | vcaballero | |
861 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
862 | .getDefaultFeatureType(), null, "Layer ASC"); |
||
863 | 20688 | jmvivo | assertEquals(57, fc.size());
|
864 | 20579 | jmvivo | it = fc.iterator(); |
865 | 23010 | jmvivo | count = 0;
|
866 | pfeature = (Feature) it.next(); |
||
867 | 19654 | vcaballero | count++; |
868 | 23010 | jmvivo | while (it.hasNext()) {
|
869 | feature = (Feature) it.next(); |
||
870 | v1 = (Comparable) pfeature.get("Layer"); |
||
871 | v2 = (Comparable) feature.get("Layer"); |
||
872 | if (v2 == null) { |
||
873 | 20579 | jmvivo | System.out.println("null"); |
874 | 23010 | jmvivo | } |
875 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) <= 0)); |
876 | 23010 | jmvivo | pfeature = feature; |
877 | 20579 | jmvivo | count++; |
878 | } |
||
879 | 23010 | jmvivo | assertEquals("Iteration error", 57, count); |
880 | 19654 | vcaballero | |
881 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
882 | .getDefaultFeatureType(), null, "Layer DESC"); |
||
883 | 20688 | jmvivo | assertEquals(57, fc.size());
|
884 | 20579 | jmvivo | it = fc.iterator(); |
885 | 19654 | vcaballero | |
886 | 23010 | jmvivo | count = 0;
|
887 | pfeature = (Feature) it.next(); |
||
888 | 19654 | vcaballero | count++; |
889 | 23010 | jmvivo | while (it.hasNext()) {
|
890 | feature = (Feature) it.next(); |
||
891 | v1 = (Comparable) pfeature.get("Layer"); |
||
892 | v2 = (Comparable) feature.get("Layer"); |
||
893 | 20579 | jmvivo | assertTrue("Short error", (v1.compareTo(v2) >= 0)); |
894 | 23010 | jmvivo | pfeature = feature; |
895 | 20579 | jmvivo | count++; |
896 | } |
||
897 | 23010 | jmvivo | assertEquals("Iteration error", 57, count); |
898 | 19654 | vcaballero | |
899 | 23010 | jmvivo | fc = (FeatureCollection) fs.getDataCollection(fs |
900 | .getDefaultFeatureType(), "Color > '7'", "Layer ASC"); |
||
901 | 19654 | vcaballero | |
902 | 20688 | jmvivo | assertEquals(45, fc.size());
|
903 | 19654 | vcaballero | |
904 | 20579 | jmvivo | it = fc.iterator(); |
905 | 19654 | vcaballero | |
906 | 23010 | jmvivo | count = 0;
|
907 | pfeature = (Feature) it.next(); |
||
908 | assertTrue(pfeature.getInt("Color") > 7); |
||
909 | 19654 | vcaballero | count++; |
910 | 23010 | jmvivo | while (it.hasNext()) {
|
911 | feature = (Feature) it.next(); |
||
912 | assertTrue("Filter error", feature.getInt("Color") > 7); |
||
913 | v1 = (Comparable) pfeature.get("Layer"); |
||
914 | v2 = (Comparable) feature.get("Layer"); |
||
915 | pfeature = feature; |
||
916 | Integer i1 = (Integer) v1; |
||
917 | Integer i2 = (Integer) v2; |
||
918 | assertTrue("Short error", (i1.intValue() <= i2.intValue()));
|
||
919 | 20579 | jmvivo | count++; |
920 | } |
||
921 | 23010 | jmvivo | assertEquals("Iteration error", 45, count); |
922 | 19654 | vcaballero | |
923 | 23010 | jmvivo | // fc = (FeatureCollection)fs.getDataCollection(null,null,"Color,Layer Desc");
|
924 | // assertEquals(10, fc.size());
|
||
925 | // it = fc.iterator();
|
||
926 | // count=0;
|
||
927 | // pfeature = (Feature)it.next();
|
||
928 | // System.out.println(pfeature.getString("Layer"));
|
||
929 | // count++;
|
||
930 | // while (it.hasNext()){
|
||
931 | // feature = (Feature)it.next();
|
||
932 | // v1 = (Comparable)((String)pfeature.get("Layer")).toLowerCase();
|
||
933 | // v2 = (Comparable)((String)feature.get("Layer")).toLowerCase();
|
||
934 | // pfeature=feature;
|
||
935 | // assertTrue("Short error", (v1.compareTo(v2) >= 0));
|
||
936 | // System.out.println(pfeature.getString("Layer"));
|
||
937 | // count++;
|
||
938 | // }
|
||
939 | // assertEquals("Iteration error",10,count);
|
||
940 | 19654 | vcaballero | |
941 | 23010 | jmvivo | // try {
|
942 | // fs.close();
|
||
943 | // } catch (CloseException e) {
|
||
944 | // e.printStackTrace();
|
||
945 | // fail("Exception:" + e);
|
||
946 | // }
|
||
947 | 19654 | vcaballero | |
948 | 20579 | jmvivo | System.out.println("======= /DGN =============="); |
949 | 19658 | vcaballero | } catch (OpenException e1) {
|
950 | e1.printStackTrace(); |
||
951 | fail(); |
||
952 | } catch (ReadException e) {
|
||
953 | // TODO Auto-generated catch block
|
||
954 | e.printStackTrace(); |
||
955 | } |
||
956 | 19654 | vcaballero | } |
957 | |||
958 | 23010 | jmvivo | // private FeatureStore createFeatureStore(IDriverParameters dp){
|
959 | // DataSourceManager dsm=DataSourceManager.getManager();
|
||
960 | 19654 | vcaballero | |
961 | 23010 | jmvivo | // DataStoreParameters dsp=dsm.createDataStoreParameters(DriverStore.DATASTORE_NAME);
|
962 | 19654 | vcaballero | |
963 | 23010 | jmvivo | // ((IDriverStoreParameters)dsp).setDriverParameters(dp);
|
964 | // FeatureStore fs=null;
|
||
965 | // try {
|
||
966 | // fs = (FeatureStore)dsm.createDataStore(dsp);
|
||
967 | // } catch (InitializeException e) {
|
||
968 | // e.printStackTrace();
|
||
969 | // fail("Exception:" + e);
|
||
970 | // }
|
||
971 | // return fs;
|
||
972 | 19654 | vcaballero | |
973 | 23010 | jmvivo | // }
|
974 | 19654 | vcaballero | |
975 | 23010 | jmvivo | private void driverTest(DataStoreParameters dp, String filter, |
976 | String order, boolean testEdit) { |
||
977 | DataManager dsm = DataManager.getManager(); |
||
978 | 19654 | vcaballero | |
979 | 23303 | jmvivo | |
980 | 23010 | jmvivo | // DataStoreParameters dsp=dsm.createDataStoreParameters(DriverStore.DATASTORE_NAME);
|
981 | 20579 | jmvivo | |
982 | 23010 | jmvivo | // ((IDriverStoreParameters)dsp).setDriverParameters(dp);
|
983 | // FeatureStore fs=createFeatureStore(dp);
|
||
984 | FeatureStore fs = null;
|
||
985 | 19443 | vcaballero | try {
|
986 | 23010 | jmvivo | fs = (FeatureStore) dsm.createDataStore(dp); |
987 | 19443 | vcaballero | } catch (InitializeException e) {
|
988 | 19470 | jmvivo | e.printStackTrace(); |
989 | 19468 | jmvivo | fail("Exception:" + e);
|
990 | 19443 | vcaballero | } |
991 | 23010 | jmvivo | // try {
|
992 | // fs.open();
|
||
993 | // } catch (OpenException e2) {
|
||
994 | // e2.printStackTrace();
|
||
995 | // fail();
|
||
996 | // }
|
||
997 | 19401 | vcaballero | |
998 | 19472 | jmvivo | if (fs.isEditable() && testEdit) {
|
999 | 19834 | jmvivo | try {
|
1000 | fs.startEditing(); |
||
1001 | 23010 | jmvivo | if (fs.canAlterFeatureType()) {
|
1002 | FeatureType featureType = fs.getDefaultFeatureType(); |
||
1003 | // DefaultAttributeDescriptor dad=new DefaultAttributeDescriptor();
|
||
1004 | // dad.loading();
|
||
1005 | // dad.setName("Prueba1");
|
||
1006 | // dad.setDefaultValue("11p");
|
||
1007 | // dad.setSize(10);
|
||
1008 | // dad.setType(FeatureAttributeDescriptor.TYPE_STRING);
|
||
1009 | // dad.stopLoading();
|
||
1010 | // fs.insert(dad);
|
||
1011 | // fs.delete((FeatureAttributeDescriptor)featureType.get(featureType.getFieldIndex("Prueba1")));
|
||
1012 | AttributeDescriptor dad2 = (AttributeDescriptor) featureType |
||
1013 | .get(featureType.getFieldIndex("TIPO"));
|
||
1014 | 20470 | vcaballero | dad2.editing(); |
1015 | 23010 | jmvivo | // dad2.setName("TIPO");
|
1016 | 20470 | vcaballero | dad2.setDefaultValue("Tipop");
|
1017 | 23010 | jmvivo | // dad2.setSize(10);
|
1018 | 21045 | jmvivo | dad2.setType(FeatureAttributeDescriptor.TYPE_STRING); |
1019 | 20470 | vcaballero | fs.update(dad2); |
1020 | } |
||
1021 | 20850 | jmvivo | } catch (DataException e) {
|
1022 | 23010 | jmvivo | e.printStackTrace(); |
1023 | fail(); |
||
1024 | 20501 | vcaballero | } |
1025 | 20414 | vcaballero | try {
|
1026 | 21045 | jmvivo | Feature feature1 = fs.createDefaultFeature(false);
|
1027 | 19449 | jmvivo | |
1028 | 21045 | jmvivo | Feature feature2 = fs.createDefaultFeature(false);
|
1029 | Feature feature3 = fs.createDefaultFeature(false);
|
||
1030 | 19449 | jmvivo | |
1031 | 20579 | jmvivo | fs.insert(feature1); |
1032 | fs.insert(feature2); |
||
1033 | 19449 | jmvivo | |
1034 | 20579 | jmvivo | feature1.editing(); |
1035 | 23010 | jmvivo | feature1.set(1, "hola"); |
1036 | 20421 | vcaballero | |
1037 | 20579 | jmvivo | fs.update(feature1); |
1038 | fs.delete(feature3); |
||
1039 | fs.delete(feature2); |
||
1040 | } catch (DataException e) {
|
||
1041 | 20414 | vcaballero | // TODO Auto-generated catch block
|
1042 | e.printStackTrace(); |
||
1043 | } |
||
1044 | 19449 | jmvivo | } |
1045 | |||
1046 | 19401 | vcaballero | //Mostrar por consola todos los registros.
|
1047 | 23010 | jmvivo | FeatureType ft = fs.getDefaultFeatureType(); |
1048 | FeatureCollection featureCollection = null;
|
||
1049 | // featureCollection = (FeatureCollection)fs.getDataCollection();
|
||
1050 | // featureCollection = (FeatureCollection)fs.getDataCollection(ft,"NOMBRE = 'CALPE'",null);
|
||
1051 | // featureCollection = (FeatureCollection)fs.getDataCollection(ft,"AREA > 3.2213163729E7 and AREA < 3.2213163749E7",null);
|
||
1052 | 19658 | vcaballero | try {
|
1053 | 23010 | jmvivo | featureCollection = (FeatureCollection) fs.getDataCollection(ft, |
1054 | filter, order); |
||
1055 | 19658 | vcaballero | } catch (ReadException e2) {
|
1056 | // TODO Auto-generated catch block
|
||
1057 | e2.printStackTrace(); |
||
1058 | } |
||
1059 | 19449 | jmvivo | |
1060 | 23010 | jmvivo | PrintlnFeaturesVisitor visitor = new PrintlnFeaturesVisitor(ft);
|
1061 | 19490 | jpiera | try {
|
1062 | featureCollection.accept(visitor); |
||
1063 | } catch (BaseException e1) {
|
||
1064 | e1.printStackTrace(); |
||
1065 | 23010 | jmvivo | fail("Exception: " + e1);
|
1066 | 19490 | jpiera | } |
1067 | 19449 | jmvivo | |
1068 | 19976 | jmvivo | featureCollection.dispose(); |
1069 | |||
1070 | 23010 | jmvivo | if (fs.isEditable() && testEdit) {
|
1071 | 19449 | jmvivo | try {
|
1072 | fs.finishEditing(); |
||
1073 | } catch (WriteException e) {
|
||
1074 | e.printStackTrace(); |
||
1075 | 23010 | jmvivo | fail("Exception: " + e);
|
1076 | 19449 | jmvivo | } catch (ReadException e) {
|
1077 | e.printStackTrace(); |
||
1078 | 23010 | jmvivo | fail("Exception: " + e);
|
1079 | 19449 | jmvivo | } |
1080 | 23543 | jmvivo | long t1 = System.currentTimeMillis(); |
1081 | while (System.currentTimeMillis() - t1 > 2000) { |
||
1082 | //Esperamos 2 seg para no tener problemas con
|
||
1083 | // los lastUpdate de los ficheros
|
||
1084 | } |
||
1085 | 19449 | jmvivo | } |
1086 | 23010 | jmvivo | // try {
|
1087 | // fs.close();
|
||
1088 | // } catch (CloseException e) {
|
||
1089 | // e.printStackTrace();
|
||
1090 | // fail("Exception: "+e);
|
||
1091 | // }
|
||
1092 | 19443 | vcaballero | try {
|
1093 | 19736 | vcaballero | fs.dispose(); |
1094 | } catch (CloseException e) {
|
||
1095 | // TODO Auto-generated catch block
|
||
1096 | e.printStackTrace(); |
||
1097 | } |
||
1098 | 23010 | jmvivo | persistenceTest(dp); |
1099 | 23543 | jmvivo | mapParamsBaseTest(dp); |
1100 | |||
1101 | 19401 | vcaballero | } |
1102 | 20660 | jmvivo | |
1103 | 21045 | jmvivo | public static void doFileResourceTest(FileStoreParameters params) { |
1104 | 23010 | jmvivo | doFileResourceTest(params, true);
|
1105 | 20661 | jmvivo | } |
1106 | 23010 | jmvivo | |
1107 | public static void doFileResourceTest(FileStoreParameters params, |
||
1108 | boolean testEdit) {
|
||
1109 | 20660 | jmvivo | DataManager manager = DataManager.getManager(); |
1110 | |||
1111 | ResourceManager resMan = ResourceManager.getResourceManager(); |
||
1112 | |||
1113 | 23010 | jmvivo | AbstractFeatureStore store = null;
|
1114 | AbstractFeatureStore store2 = null;
|
||
1115 | AbstractFeatureStore store3 = null;
|
||
1116 | 20661 | jmvivo | try {
|
1117 | 23010 | jmvivo | store = (AbstractFeatureStore) manager.createDataStore(params); |
1118 | store2 = (AbstractFeatureStore) manager.createDataStore(params); |
||
1119 | store3 = (AbstractFeatureStore) manager.createDataStore(params); |
||
1120 | 20661 | jmvivo | } catch (InitializeException e1) {
|
1121 | 23010 | jmvivo | e1.printStackTrace(); |
1122 | fail(); |
||
1123 | 20661 | jmvivo | } |
1124 | 20660 | jmvivo | |
1125 | 23509 | jmvivo | Resource res = getResource(params); |
1126 | 20660 | jmvivo | |
1127 | 23509 | jmvivo | assertNotNull(res); |
1128 | 20660 | jmvivo | |
1129 | assertEquals(3, res.getRefencesCount());
|
||
1130 | |||
1131 | 20661 | jmvivo | try {
|
1132 | store.close(); |
||
1133 | } catch (CloseException e1) {
|
||
1134 | 23010 | jmvivo | e1.printStackTrace(); |
1135 | fail(); |
||
1136 | 20661 | jmvivo | } |
1137 | 20660 | jmvivo | |
1138 | assertEquals(false, res.isOpen());
|
||
1139 | |||
1140 | 21045 | jmvivo | DataCollection coll = null;
|
1141 | 20660 | jmvivo | |
1142 | 20661 | jmvivo | try {
|
1143 | 23010 | jmvivo | coll = store.getDataCollection(); |
1144 | 20661 | jmvivo | } catch (ReadException e1) {
|
1145 | 23010 | jmvivo | e1.printStackTrace(); |
1146 | fail(); |
||
1147 | 20661 | jmvivo | } |
1148 | 20660 | jmvivo | |
1149 | coll.iterator().next(); |
||
1150 | 23010 | jmvivo | // coll.size();
|
1151 | 20660 | jmvivo | |
1152 | assertEquals(true, res.isOpen());
|
||
1153 | |||
1154 | coll.dispose(); |
||
1155 | |||
1156 | 23010 | jmvivo | if (store.isEditable() && testEdit) {
|
1157 | /* Test edition notification */
|
||
1158 | 20660 | jmvivo | |
1159 | 23010 | jmvivo | int fCountOrg = 0; |
1160 | int fCountFin = 0; |
||
1161 | 20661 | jmvivo | try {
|
1162 | 20688 | jmvivo | fCountOrg = store.getDataCollection().size(); |
1163 | } catch (ReadException e2) {
|
||
1164 | // TODO Auto-generated catch block
|
||
1165 | 23010 | jmvivo | e2.printStackTrace(); |
1166 | fail("Exception: " + e2);
|
||
1167 | 20688 | jmvivo | } |
1168 | try {
|
||
1169 | 20661 | jmvivo | store.startEditing(); |
1170 | } catch (ReadException e1) {
|
||
1171 | 23010 | jmvivo | e1.printStackTrace(); |
1172 | fail("Exception: " + e1);
|
||
1173 | 20661 | jmvivo | } |
1174 | |||
1175 | try {
|
||
1176 | coll = store2.getDataCollection(); |
||
1177 | } catch (ReadException e1) {
|
||
1178 | 23010 | jmvivo | e1.printStackTrace(); |
1179 | fail("Exception: " + e1);
|
||
1180 | 20661 | jmvivo | } |
1181 | |||
1182 | try {
|
||
1183 | store.finishEditing(); |
||
1184 | } catch (WriteException e1) {
|
||
1185 | 23010 | jmvivo | e1.printStackTrace(); |
1186 | fail("Exception: " + e1);
|
||
1187 | 20661 | jmvivo | } catch (ReadException e1) {
|
1188 | 23010 | jmvivo | e1.printStackTrace(); |
1189 | fail("Exception: " + e1);
|
||
1190 | 20661 | jmvivo | } |
1191 | |||
1192 | 20688 | jmvivo | try {
|
1193 | fCountFin = store.getDataCollection().size(); |
||
1194 | } catch (ReadException e2) {
|
||
1195 | // TODO Auto-generated catch block
|
||
1196 | 23010 | jmvivo | e2.printStackTrace(); |
1197 | fail("Exception: " + e2);
|
||
1198 | 20688 | jmvivo | } |
1199 | |||
1200 | assertEquals(fCountOrg, fCountFin); |
||
1201 | |||
1202 | 20661 | jmvivo | boolean isOk = false; |
1203 | 23010 | jmvivo | try {
|
1204 | 20661 | jmvivo | coll.iterator().next(); |
1205 | 23010 | jmvivo | } catch (Exception e) { |
1206 | isOk = true;
|
||
1207 | 20661 | jmvivo | } |
1208 | 23010 | jmvivo | assertTrue("Resource Changed Notification fails", isOk);
|
1209 | 20661 | jmvivo | |
1210 | coll.dispose(); |
||
1211 | |||
1212 | 20688 | jmvivo | long time = System.currentTimeMillis(); |
1213 | 23010 | jmvivo | while ((System.currentTimeMillis() - time) < 1000) { |
1214 | 20688 | jmvivo | //sleep
|
1215 | } |
||
1216 | |||
1217 | 23010 | jmvivo | ((FileResource) res).getFile().setLastModified( |
1218 | System.currentTimeMillis());
|
||
1219 | 20688 | jmvivo | |
1220 | 23010 | jmvivo | isOk = false;
|
1221 | try {
|
||
1222 | 20688 | jmvivo | store.getDataCollection().iterator().next(); |
1223 | 23010 | jmvivo | } catch (Exception e) { |
1224 | isOk = true;
|
||
1225 | 20661 | jmvivo | } |
1226 | 23010 | jmvivo | assertTrue("Resource Changed Notification fails", isOk);
|
1227 | 20661 | jmvivo | |
1228 | 23010 | jmvivo | /* Test edition notification END */
|
1229 | 20661 | jmvivo | |
1230 | } |
||
1231 | |||
1232 | try {
|
||
1233 | store3.dispose(); |
||
1234 | } catch (CloseException e1) {
|
||
1235 | 23010 | jmvivo | e1.printStackTrace(); |
1236 | fail(); |
||
1237 | 20661 | jmvivo | } |
1238 | |||
1239 | 20660 | jmvivo | assertEquals(2, res.getRefencesCount());
|
1240 | |||
1241 | 20661 | jmvivo | try {
|
1242 | store2.dispose(); |
||
1243 | } catch (CloseException e1) {
|
||
1244 | 23010 | jmvivo | e1.printStackTrace(); |
1245 | fail(); |
||
1246 | 20661 | jmvivo | } |
1247 | 20660 | jmvivo | |
1248 | assertEquals(1, res.getRefencesCount());
|
||
1249 | |||
1250 | 23551 | jiyarza | store = null;
|
1251 | System.gc();
|
||
1252 | System.gc();
|
||
1253 | System.gc();
|
||
1254 | 20660 | jmvivo | |
1255 | assertEquals(0, res.getRefencesCount());
|
||
1256 | 23570 | jmvivo | try {
|
1257 | resMan.collectDeadResources(); |
||
1258 | } catch (DataException e) {
|
||
1259 | e.printStackTrace(); |
||
1260 | fail(); |
||
1261 | return;
|
||
1262 | } |
||
1263 | 23509 | jmvivo | res = getResource(params); |
1264 | 20660 | jmvivo | |
1265 | 23509 | jmvivo | assertNull(res); |
1266 | 20660 | jmvivo | |
1267 | 20732 | jmvivo | doPrepareFileResourceTest(params); |
1268 | 20660 | jmvivo | |
1269 | 20732 | jmvivo | } |
1270 | 20661 | jmvivo | |
1271 | 23010 | jmvivo | public static void doPrepareFileResourceTest(FileStoreParameters params) { |
1272 | 20732 | jmvivo | DataManager manager = DataManager.getManager(); |
1273 | |||
1274 | ResourceManager resMan = ResourceManager.getResourceManager(); |
||
1275 | |||
1276 | File originalFile = params.getFile();
|
||
1277 | params.setFile(new File(originalFile.getName())); |
||
1278 | |||
1279 | 21045 | jmvivo | Observer obs = new PrepareResourceObserver(originalFile); |
1280 | 20732 | jmvivo | |
1281 | resMan.addObserver(obs); |
||
1282 | |||
1283 | 23010 | jmvivo | AbstractFeatureStore store = null;
|
1284 | 20732 | jmvivo | try {
|
1285 | 23010 | jmvivo | store = (AbstractFeatureStore) manager.createDataStore(params); |
1286 | 20732 | jmvivo | } catch (InitializeException e1) {
|
1287 | 23010 | jmvivo | e1.printStackTrace(); |
1288 | fail(); |
||
1289 | } catch (Exception e2) { |
||
1290 | e2.printStackTrace(); |
||
1291 | fail(); |
||
1292 | 20732 | jmvivo | } |
1293 | |||
1294 | try {
|
||
1295 | store.getDataCollection().iterator().next(); |
||
1296 | } catch (ReadException e) {
|
||
1297 | // TODO Auto-generated catch block
|
||
1298 | 23010 | jmvivo | e.printStackTrace(); |
1299 | fail(); |
||
1300 | 20732 | jmvivo | } |
1301 | |||
1302 | try {
|
||
1303 | store.close(); |
||
1304 | } catch (CloseException e) {
|
||
1305 | // TODO Auto-generated catch block
|
||
1306 | 23010 | jmvivo | e.printStackTrace(); |
1307 | fail(); |
||
1308 | 20732 | jmvivo | } |
1309 | try {
|
||
1310 | store.dispose(); |
||
1311 | } catch (CloseException e) {
|
||
1312 | // TODO Auto-generated catch block
|
||
1313 | 23010 | jmvivo | e.printStackTrace(); |
1314 | fail(); |
||
1315 | 20732 | jmvivo | } |
1316 | |||
1317 | 20660 | jmvivo | } |
1318 | 20732 | jmvivo | |
1319 | 23010 | jmvivo | private void persistenceTest(DataStoreParameters params) { |
1320 | DataManager manager = DataManager.getManager(); |
||
1321 | |||
1322 | DataStoreParameters params2 = null;
|
||
1323 | XMLEntity paramsXML = null;
|
||
1324 | XMLEntity params2XML = null;
|
||
1325 | |||
1326 | paramsXML = params.getXMLEntity(); |
||
1327 | |||
1328 | try {
|
||
1329 | params2 = manager.createDataStoreParameters(paramsXML); |
||
1330 | } catch (InitializeException e) {
|
||
1331 | e.printStackTrace(); |
||
1332 | fail(); |
||
1333 | } |
||
1334 | |||
1335 | params2XML = params2.getXMLEntity(); |
||
1336 | |||
1337 | assertEquals(paramsXML.toString(), params2XML.toString()); |
||
1338 | |||
1339 | FeatureStore store = null;
|
||
1340 | XMLEntity storeXML = null;
|
||
1341 | FeatureStore store2 = null;
|
||
1342 | XMLEntity store2XML = null;
|
||
1343 | |||
1344 | try {
|
||
1345 | store = (FeatureStore) manager.createDataStore(params); |
||
1346 | } catch (InitializeException e) {
|
||
1347 | e.printStackTrace(); |
||
1348 | fail(); |
||
1349 | } |
||
1350 | |||
1351 | 23181 | vcaballero | try {
|
1352 | storeXML = store.getXMLEntity(); |
||
1353 | } catch (XMLException e1) {
|
||
1354 | e1.printStackTrace(); |
||
1355 | fail(); |
||
1356 | } |
||
1357 | 23010 | jmvivo | |
1358 | assertNotNull(storeXML); |
||
1359 | |||
1360 | try {
|
||
1361 | store2 = (FeatureStore) manager.createDataStore(storeXML); |
||
1362 | } catch (InitializeException e) {
|
||
1363 | e.printStackTrace(); |
||
1364 | fail(); |
||
1365 | } |
||
1366 | |||
1367 | 23181 | vcaballero | try {
|
1368 | store2XML = store2.getXMLEntity(); |
||
1369 | } catch (XMLException e1) {
|
||
1370 | e1.printStackTrace(); |
||
1371 | fail(); |
||
1372 | } |
||
1373 | 23010 | jmvivo | |
1374 | assertEquals(storeXML.toString(), store2XML.toString()); |
||
1375 | |||
1376 | FeatureCollection coll = null;
|
||
1377 | FeatureCollection coll2 = null;
|
||
1378 | Iterator iter = null; |
||
1379 | Iterator iter2 = null; |
||
1380 | Feature feature=null;
|
||
1381 | Feature feature2 = null;
|
||
1382 | Comparable v1 = null; |
||
1383 | Comparable v2 = null; |
||
1384 | Handler h = null; |
||
1385 | Handler h2 = null; |
||
1386 | |||
1387 | |||
1388 | try {
|
||
1389 | coll = (FeatureCollection) store.getDataCollection(); |
||
1390 | coll2 = (FeatureCollection) store2.getDataCollection(); |
||
1391 | } catch (ReadException e) {
|
||
1392 | e.printStackTrace(); |
||
1393 | fail(); |
||
1394 | } |
||
1395 | |||
1396 | assertEquals(coll.size(), coll2.size()); |
||
1397 | |||
1398 | iter = coll.iterator(); |
||
1399 | iter2 = coll2.iterator(); |
||
1400 | int i;
|
||
1401 | int featureSize = store.getDefaultFeatureType().size();
|
||
1402 | |||
1403 | try {
|
||
1404 | while (iter.hasNext()) {
|
||
1405 | feature = (Feature) iter.next(); |
||
1406 | feature2 = (Feature) iter2.next(); |
||
1407 | for (i = 0; i < featureSize; i++) { |
||
1408 | v1 = (Comparable) feature.get(i);
|
||
1409 | v2 = (Comparable) feature2.get(i);
|
||
1410 | if (v1 == null) { |
||
1411 | assertNull(v2); |
||
1412 | } else if (v1 instanceof Geometry) { |
||
1413 | assertTrue(v2 instanceof Geometry);
|
||
1414 | assertEquals(((Geometry) v1).getType(), ((Geometry) v2) |
||
1415 | .getType()); |
||
1416 | assertEquals( |
||
1417 | (((Geometry) v1) |
||
1418 | .getHandlers(Geometry.SELECTHANDLER)).length, |
||
1419 | (((Geometry) v2) |
||
1420 | .getHandlers(Geometry.SELECTHANDLER)).length); |
||
1421 | h = (((Geometry) v1) |
||
1422 | .getHandlers(Geometry.SELECTHANDLER))[0];
|
||
1423 | h2 = (((Geometry) v2) |
||
1424 | .getHandlers(Geometry.SELECTHANDLER))[0];
|
||
1425 | |||
1426 | assertEquals(0.0, h.getPoint().distance(h2.getPoint()),
|
||
1427 | 0.000001);
|
||
1428 | |||
1429 | h = (((Geometry) v1) |
||
1430 | .getHandlers(Geometry.SELECTHANDLER))[(((Geometry) v1) |
||
1431 | .getHandlers(Geometry.SELECTHANDLER)).length - 1];
|
||
1432 | h2 = (((Geometry) v2) |
||
1433 | .getHandlers(Geometry.SELECTHANDLER))[(((Geometry) v2) |
||
1434 | .getHandlers(Geometry.SELECTHANDLER)).length - 1];
|
||
1435 | |||
1436 | assertEquals(0.0, h.getPoint().distance(h2.getPoint()),
|
||
1437 | 0.000001);
|
||
1438 | |||
1439 | } else {
|
||
1440 | assertEquals(0, v1.compareTo(v2));
|
||
1441 | } |
||
1442 | } |
||
1443 | |||
1444 | |||
1445 | } |
||
1446 | } catch (Exception e) { |
||
1447 | e.printStackTrace(); |
||
1448 | fail(); |
||
1449 | } |
||
1450 | |||
1451 | coll.dispose(); |
||
1452 | coll2.dispose(); |
||
1453 | |||
1454 | try {
|
||
1455 | store.dispose(); |
||
1456 | store2.dispose(); |
||
1457 | } catch (CloseException e) {
|
||
1458 | e.printStackTrace(); |
||
1459 | fail(); |
||
1460 | } |
||
1461 | |||
1462 | } |
||
1463 | 23303 | jmvivo | |
1464 | public void cloneFeatureTypeTest() { |
||
1465 | |||
1466 | org.gvsig.fmap.data.feature.file.dbf.Register.selfRegister(); |
||
1467 | |||
1468 | DataManager dsm = DataManager.getManager(); |
||
1469 | |||
1470 | DataStoreParameters dp; |
||
1471 | try {
|
||
1472 | dp = dsm.createDataStoreParameters(DBFStore.DATASTORE_NAME); |
||
1473 | } catch (InitializeException e1) {
|
||
1474 | e1.printStackTrace(); |
||
1475 | fail(); |
||
1476 | return;
|
||
1477 | } |
||
1478 | ((DBFStoreParameters) dp).setFile(dbffile); |
||
1479 | |||
1480 | FeatureStore fs = null;
|
||
1481 | try {
|
||
1482 | fs = (FeatureStore) dsm.createDataStore(dp); |
||
1483 | } catch (InitializeException e) {
|
||
1484 | e.printStackTrace(); |
||
1485 | fail("Exception:" + e);
|
||
1486 | return;
|
||
1487 | } |
||
1488 | assertNotNull("Can't create Feature Store", fs);
|
||
1489 | |||
1490 | compareFeatureType(fs.getDefaultFeatureType(), fs |
||
1491 | .getDefaultFeatureType() |
||
1492 | .cloneFeatureType()); |
||
1493 | |||
1494 | FeatureCollection fc = null;
|
||
1495 | |||
1496 | try {
|
||
1497 | fc = (FeatureCollection) fs.getDataCollection(); |
||
1498 | } catch (ReadException e1) {
|
||
1499 | e1.printStackTrace(); |
||
1500 | fail(); |
||
1501 | return;
|
||
1502 | } |
||
1503 | |||
1504 | |||
1505 | compareFeatureType(fs.getDefaultFeatureType(), fc.getFeatureType()); |
||
1506 | |||
1507 | |||
1508 | |||
1509 | fc.dispose(); |
||
1510 | |||
1511 | try {
|
||
1512 | fs.addEvaluatedAttribute(null, "eva1", |
||
1513 | FeatureAttributeDescriptor.TYPE_STRING, "lower(' ')", null); |
||
1514 | } catch (ReadException e1) {
|
||
1515 | e1.printStackTrace(); |
||
1516 | fail(); |
||
1517 | return;
|
||
1518 | } |
||
1519 | |||
1520 | |||
1521 | compareFeatureType(fs.getDefaultFeatureType(), fs |
||
1522 | .getDefaultFeatureType().cloneFeatureType()); |
||
1523 | |||
1524 | try {
|
||
1525 | fs.dispose(); |
||
1526 | } catch (CloseException e) {
|
||
1527 | e.printStackTrace(); |
||
1528 | fail(); |
||
1529 | return;
|
||
1530 | } |
||
1531 | } |
||
1532 | |||
1533 | private void compareFeatureType(FeatureType original, FeatureType copy) { |
||
1534 | AttributeDescriptor attr1, attr2; |
||
1535 | |||
1536 | assertEquals(original.size(), copy.size()); |
||
1537 | assertEquals(original.getDefaultGeometry(), copy.getDefaultGeometry()); |
||
1538 | |||
1539 | int i = 0; |
||
1540 | |||
1541 | for (i = 0; i < original.size(); i++) { |
||
1542 | attr1 = (AttributeDescriptor) original.get(i); |
||
1543 | attr2 = (AttributeDescriptor) copy.get(i); |
||
1544 | |||
1545 | assertEquals(attr1.getName(), attr2.getName()); |
||
1546 | assertEquals(attr1.getDataType(), attr2.getDataType()); |
||
1547 | assertEquals(attr1.getDefaultValue(), attr2.getDefaultValue()); |
||
1548 | assertEquals(attr1.ordinal(), attr2.ordinal()); |
||
1549 | assertEquals(attr1.originalPosition(), attr2.originalPosition()); |
||
1550 | assertEquals(attr1.isEvaluated(), attr2.isEvaluated()); |
||
1551 | assertEquals(attr1.getGeometryType(), attr2.getGeometryType()); |
||
1552 | assertEquals(attr1.getSize(), attr2.getSize()); |
||
1553 | assertEquals(attr1.getSRS(), attr2.getSRS()); |
||
1554 | assertEquals(attr1.getPrecision(), attr2.getPrecision()); |
||
1555 | assertEquals(attr1.getExpression(), attr2.getExpression()); |
||
1556 | assertEquals(attr1.isAllowNull(), attr2.isAllowNull()); |
||
1557 | assertEquals(attr1.isPrimaryKey(), attr2.isPrimaryKey()); |
||
1558 | assertEquals(attr1.isReadOnly(), attr2.isReadOnly()); |
||
1559 | } |
||
1560 | |||
1561 | } |
||
1562 | 23509 | jmvivo | |
1563 | protected static Resource getResource(FileStoreParameters params) { |
||
1564 | Resource tmpRes = null;
|
||
1565 | Object obj = null; |
||
1566 | |||
1567 | ResourceManager resMan = ResourceManager.getResourceManager(); |
||
1568 | |||
1569 | Iterator iter = resMan.iterator();
|
||
1570 | while (iter.hasNext()) {
|
||
1571 | obj = iter.next(); |
||
1572 | if (obj instanceof FileResource) { |
||
1573 | tmpRes = (Resource) obj; |
||
1574 | if (((FileResource) tmpRes).getFile().getAbsoluteFile().equals(
|
||
1575 | params.getFile().getAbsoluteFile())) { |
||
1576 | return tmpRes;
|
||
1577 | } |
||
1578 | } |
||
1579 | } |
||
1580 | return null; |
||
1581 | } |
||
1582 | 23543 | jmvivo | |
1583 | private void mapParamsBaseTest(DataParameters params) { |
||
1584 | Exception e = null; |
||
1585 | try {
|
||
1586 | params.put(new Integer(0), "GEOMETRY_x"); |
||
1587 | } catch (Exception e1) { |
||
1588 | e = e1; |
||
1589 | } |
||
1590 | 23602 | jmvivo | assertNull(e); |
1591 | 23543 | jmvivo | |
1592 | e = null;
|
||
1593 | try {
|
||
1594 | params.put("kk", "GEOMETRY_x"); |
||
1595 | } catch (IllegalArgumentException e1) { |
||
1596 | e = e1; |
||
1597 | } |
||
1598 | 23602 | jmvivo | assertNull(e); |
1599 | 23543 | jmvivo | |
1600 | e = null;
|
||
1601 | try {
|
||
1602 | params.entrySet(); |
||
1603 | } catch (UnsupportedOperationException e1) { |
||
1604 | e = e1; |
||
1605 | } |
||
1606 | 23602 | jmvivo | assertNull(e); |
1607 | 23543 | jmvivo | |
1608 | e = null;
|
||
1609 | try {
|
||
1610 | params.keySet().add("hola");
|
||
1611 | } catch (UnsupportedOperationException e1) { |
||
1612 | e = e1; |
||
1613 | } |
||
1614 | assertNotNull(e); |
||
1615 | |||
1616 | e = null;
|
||
1617 | try {
|
||
1618 | params.keySet().remove("storeSecondary");
|
||
1619 | } catch (UnsupportedOperationException e1) { |
||
1620 | e = e1; |
||
1621 | } |
||
1622 | assertNotNull(e); |
||
1623 | |||
1624 | e = null;
|
||
1625 | try {
|
||
1626 | params.values().remove("GEOMETRY_x");
|
||
1627 | } catch (UnsupportedOperationException e1) { |
||
1628 | e = e1; |
||
1629 | } |
||
1630 | assertNotNull(e); |
||
1631 | |||
1632 | e = null;
|
||
1633 | try {
|
||
1634 | params.values().add("GEOMETRY_x");
|
||
1635 | } catch (UnsupportedOperationException e1) { |
||
1636 | e = e1; |
||
1637 | } |
||
1638 | assertNotNull(e); |
||
1639 | |||
1640 | } |
||
1641 | |||
1642 | 19470 | jmvivo | } |