1 package org.apache.turbine.util.parser;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import java.io.File;
23 import java.io.FileInputStream;
24 import java.io.FileOutputStream;
25 import java.io.InputStreamReader;
26 import java.io.OutputStreamWriter;
27 import java.io.Reader;
28 import java.io.StringReader;
29 import java.util.Arrays;
30 import java.util.Iterator;
31 import java.util.List;
32 import java.util.NoSuchElementException;
33
34 import junit.framework.TestSuite;
35
36 import org.apache.commons.lang.StringUtils;
37 import org.apache.turbine.test.BaseTurbineTest;
38
39 /***
40 * test whether the Default parameter parser returns its uploaded file items
41 * in the keySet().
42 *
43 * @author <a href="mailto:hps@intermeta.de">Henning P. Schmiedehausen</a>
44 * @version $Id: CSVParserTest.java 534527 2007-05-02 16:10:59Z tv $
45 */
46
47 public class CSVParserTest
48 extends BaseTurbineTest
49 {
50 public CSVParserTest(String name)
51 throws Exception
52 {
53 super(name, "conf/test/TurbineResources.properties");
54 }
55
56 public static TestSuite suite()
57 {
58 return new TestSuite(CSVParserTest.class);
59 }
60
61 public void testSimpleReader()
62 {
63 String readLine = "0,1,2,3,4,5,6,7,8,9\n";
64
65 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
66 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
67
68 Reader myReader = new StringReader(readLine);
69
70 List fieldNames = Arrays.asList(fields);
71
72 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
73
74 assertTrue(p.hasNext());
75
76 ValueParser vp = (ValueParser) p.next();
77
78 assertEquals("Wrong character encoding set", "UTF-8", vp.getCharacterEncoding());
79
80 assertFalse(p.hasNext());
81
82 for (int i = 0; i < fields.length; i ++)
83 {
84 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
85 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
86 }
87 }
88
89 public void testMultipleLines()
90 {
91 String readLine = "0,1,2,3,4,5,6,7,8,9\n"
92 + "10,11,12,13,14,15,16,17,18,19\n"
93 + "20,21,22,23,24,25,26,27,28,29\n"
94 + "30,31,32,33,34,35,36,37,38,39\n"
95 + "40,41,42,43,44,45,46,47,48,49\n"
96 + "50,51,52,53,54,55,56,57,58,59\n";
97
98 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
99 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
100
101 Reader myReader = new StringReader(readLine);
102
103 List fieldNames = Arrays.asList(fields);
104
105 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
106
107 int cnt = 0;
108
109 while(p.hasNext())
110 {
111 ValueParser vp = (ValueParser) p.next();
112
113 for (int i = 0; i < fields.length; i ++)
114 {
115 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
116 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
117 values[i] += 10;
118 }
119 cnt++;
120 }
121
122 assertEquals("Wrong number of lines found", 6, cnt);
123 }
124
125 public void testPadding()
126 {
127 String [] strValues = {" 0"," 1 ","2 "," 3 "," 4"," 5 "," 6"," 7 ","8"," 9 "};
128
129 String readLine = StringUtils.join(strValues, ',') + "\n";
130
131 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
132 int [] intValues = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
133
134 Reader myReader = new StringReader(readLine);
135
136 List fieldNames = Arrays.asList(fields);
137
138 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
139
140 assertTrue(p.hasNext());
141
142 ValueParser vp = (ValueParser) p.next();
143
144 assertFalse(p.hasNext());
145
146 for (int i = 0; i < fields.length; i ++)
147 {
148 assertEquals("Value does not match", strValues[i], vp.getString(fields[i]));
149 assertEquals("Value does not match", intValues[i], vp.getInt(fields[i]));
150 }
151 }
152
153 public void testMissing()
154 {
155 String [] strValues = { "100", "", "300", "", "500", "", "700", "", "900", ""};
156
157 String readLine = StringUtils.join(strValues, ',') + "\n";
158
159 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
160 int [] intValues = { 100, 200, 300, 400, 500, 600, 700, 800, 900, 0 };
161
162 Reader myReader = new StringReader(readLine);
163
164 List fieldNames = Arrays.asList(fields);
165
166 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
167
168 assertTrue(p.hasNext());
169
170 ValueParser vp = (ValueParser) p.next();
171
172 assertFalse(p.hasNext());
173
174 for (int i = 0; i < fields.length; i ++)
175 {
176 assertEquals("Value does not match", strValues[i], vp.getString(fields[i]));
177
178 if ((i % 2) == 0)
179 {
180 assertEquals("Value does not match", intValues[i], vp.getInt(fields[i]));
181 }
182 }
183 }
184
185
186 public void testEmpty()
187 {
188 String readLine = "\n";
189
190 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
191
192 Reader myReader = new StringReader(readLine);
193
194 List fieldNames = Arrays.asList(fields);
195
196 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
197
198 assertTrue(p.hasNext());
199
200 ValueParser vp = (ValueParser) p.next();
201
202 assertFalse(p.hasNext());
203
204 for (int i = 0; i < fields.length; i ++)
205 {
206 assertEquals("Value does not match", "", vp.getString(fields[i]));
207 }
208 }
209
210 public void testEOF()
211 {
212 String readLine = "0,1,2,3,4,5,6,7,8,9";
213
214 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
215 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
216
217 Reader myReader = new StringReader(readLine);
218
219 List fieldNames = Arrays.asList(fields);
220
221 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
222
223 assertTrue(p.hasNext());
224
225 ValueParser vp = (ValueParser) p.next();
226
227 assertFalse(p.hasNext());
228
229 for (int i = 0; i < fields.length; i ++)
230 {
231 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
232 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
233 }
234 }
235
236 public void testLessFields()
237 {
238 String readLine = "0,1,2,3,4,5,6,7,8,9";
239
240 String [] fields = { "eins", "zwei", "drei" };
241 int [] values = { 0, 1, 2, };
242
243 Reader myReader = new StringReader(readLine);
244
245 List fieldNames = Arrays.asList(fields);
246
247 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
248
249 assertTrue(p.hasNext());
250
251 ValueParser vp = (ValueParser) p.next();
252
253 assertFalse(p.hasNext());
254
255 for (int i = 0; i < fields.length; i ++)
256 {
257 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
258 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
259 }
260 }
261
262 public void testLessFieldsMultipleLines()
263 {
264 String readLine = "0,1,2,3,4,5,6,7,8,9\n"
265 + "10,11,12,13,14,15,16,17,18,19\n"
266 + "20,21,22,23,24,25,26,27,28,29\n"
267 + "30,31,32,33,34,35,36,37,38,39\n"
268 + "40,41,42,43,44,45,46,47,48,49\n"
269 + "50,51,52,53,54,55,56,57,58,59\n";
270
271 String [] fields = { "eins", "zwei", "drei", };
272 int [] values = { 0, 1, 2, };
273
274 Reader myReader = new StringReader(readLine);
275
276 List fieldNames = Arrays.asList(fields);
277
278 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
279
280 int cnt = 0;
281
282 while(p.hasNext())
283 {
284 ValueParser vp = (ValueParser) p.next();
285
286 for (int i = 0; i < fields.length; i ++)
287 {
288 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
289 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
290 values[i] += 10;
291 }
292 cnt++;
293 }
294
295 assertEquals("Wrong number of lines found", 6, cnt);
296 }
297
298 public void testMoreFields()
299 {
300 String readLine = "0,1,2,3\n";
301
302 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
303 int [] values = { 0, 1, 2, 3 };
304
305 Reader myReader = new StringReader(readLine);
306
307 List fieldNames = Arrays.asList(fields);
308
309 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
310
311 assertTrue(p.hasNext());
312
313 ValueParser vp = (ValueParser) p.next();
314
315 assertFalse(p.hasNext());
316
317 for (int i = 0; i < values.length; i ++)
318 {
319 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
320 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
321 }
322
323 for (int i = values.length; i < fields.length; i ++)
324 {
325 assertEquals("Value does not match", "", vp.getString(fields[i]));
326 }
327 }
328
329 public void testMoreFieldsMultipleLines()
330 {
331 String readLine = "0,1,2,3\n"
332 + "10,11,12,13\n"
333 + "20,21,22,23\n"
334 + "30,31,32,33\n"
335 + "40,41,42,43\n"
336 + "50,51,52,53\n";
337
338 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
339 int [] values = { 0, 1, 2, 3 };
340
341 Reader myReader = new StringReader(readLine);
342
343 List fieldNames = Arrays.asList(fields);
344
345 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
346
347 int cnt = 0;
348
349 while(p.hasNext())
350 {
351 ValueParser vp = (ValueParser) p.next();
352
353 for (int i = 0; i < values.length; i ++)
354 {
355 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
356 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
357 values[i] += 10;
358 }
359 for (int i = values.length; i < fields.length; i ++)
360 {
361 assertEquals("Value does not match", "", vp.getString(fields[i]));
362 }
363 cnt++;
364 }
365
366 assertEquals("Wrong number of lines found", 6, cnt);
367 }
368
369 public void testQuotedReader()
370 {
371 String readLine = "\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\"\n";
372
373 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
374 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
375
376 Reader myReader = new StringReader(readLine);
377
378 List fieldNames = Arrays.asList(fields);
379
380 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
381
382 assertTrue(p.hasNext());
383
384 ValueParser vp = (ValueParser) p.next();
385
386 assertFalse(p.hasNext());
387
388 for (int i = 0; i < fields.length; i ++)
389 {
390 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
391 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
392 }
393 }
394
395 public void testMissingTrailingQuoteEOL()
396 {
397 String readLine = "\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9\n";
398
399 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
400 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
401
402 Reader myReader = new StringReader(readLine);
403
404 List fieldNames = Arrays.asList(fields);
405
406 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
407
408 assertTrue(p.hasNext());
409
410 ValueParser vp = (ValueParser) p.next();
411
412 assertFalse(p.hasNext());
413
414 for (int i = 0; i < fields.length; i ++)
415 {
416 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
417 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
418 }
419 }
420
421 public void testMissingTrailingQuoteEOF()
422 {
423 String readLine = "\"0\",\"1\",\"2\",\"3\",\"4\",\"5\",\"6\",\"7\",\"8\",\"9";
424
425 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
426 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
427
428 Reader myReader = new StringReader(readLine);
429
430 List fieldNames = Arrays.asList(fields);
431
432 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
433
434 assertTrue(p.hasNext());
435
436 ValueParser vp = (ValueParser) p.next();
437
438 assertFalse(p.hasNext());
439
440 for (int i = 0; i < fields.length; i ++)
441 {
442 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
443 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
444 }
445 }
446
447 public void testQuotedSeparator()
448 {
449 String [] strValues = { "0,1,2,3,4,5,6,7,8,9",
450 "1","2","3","4","5","6","7","8","9"};
451
452 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
453
454 String readLine = "\"" + StringUtils.join(strValues, "\",\"") + "\"\n";
455
456 Reader myReader = new StringReader(readLine);
457
458 List fieldNames = Arrays.asList(fields);
459
460 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
461
462 assertTrue(p.hasNext());
463
464 ValueParser vp = (ValueParser) p.next();
465
466 assertFalse(p.hasNext());
467
468 for (int i = 0; i < fields.length; i ++)
469 {
470 assertEquals("Value does not match", strValues[i], vp.getString(fields[i]));
471 }
472 }
473
474 public void testQuotedQuote()
475 {
476 String [] strValues = { "//\"", };
477
478 String [] fields = { "eins", };
479
480 String readLine = "\"" + StringUtils.join(strValues, "\",\"") + "\"\n";
481
482 Reader myReader = new StringReader(readLine);
483
484 List fieldNames = Arrays.asList(fields);
485
486 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
487
488 assertTrue(p.hasNext());
489
490 ValueParser vp = (ValueParser) p.next();
491
492 assertFalse(p.hasNext());
493 assertEquals("Value does not match", "\"", vp.getString(fields[0]));
494 }
495
496 public void testExceptions()
497 {
498 String readLine = "0,1,2,3,4,5,6,7,8,9\n";
499
500 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
501
502 Reader myReader = new StringReader(readLine);
503
504 List fieldNames = Arrays.asList(fields);
505
506 DataStreamParser p = new CSVParser(myReader, fieldNames, "UTF-8");
507
508 assertTrue(p.hasNext());
509
510 p.next();
511
512 try
513 {
514 p.remove();
515 fail("remove() succeeded!");
516 }
517 catch (Exception e)
518 {
519 assertEquals("Wrong Exception thrown", UnsupportedOperationException.class, e.getClass());
520 }
521
522 assertFalse(p.hasNext());
523
524 try
525 {
526 p.next();
527 fail("next() succeeded!");
528 }
529 catch (Exception e)
530 {
531 assertEquals("Wrong Exception thrown", NoSuchElementException.class, e.getClass());
532 }
533 }
534
535 public void testEncodingFromReader()
536 {
537 String readLine = "0,1,2,3,4,5,6,7,8,9\n";
538
539 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
540 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
541
542 Reader myReader = new StringReader(readLine);
543
544 List fieldNames = Arrays.asList(fields);
545
546 DataStreamParser p = new CSVParser(myReader, fieldNames, null);
547
548 assertTrue(p.hasNext());
549
550 ValueParser vp = (ValueParser) p.next();
551
552 assertEquals("Wrong character encoding set", "US-ASCII", vp.getCharacterEncoding());
553
554 assertFalse(p.hasNext());
555
556 for (int i = 0; i < fields.length; i ++)
557 {
558 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
559 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
560 }
561 }
562
563 public void testEncodingFromStream()
564 throws Exception
565 {
566 String readLine = "0,1,2,3,4,5,6,7,8,9\n";
567
568 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
569 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
570
571 File myFile = File.createTempFile("turbine", null, null);
572
573 assertNotNull(myFile);
574
575 myFile.deleteOnExit();
576
577 FileOutputStream fos = new FileOutputStream(myFile);
578
579 assertNotNull(fos);
580
581 OutputStreamWriter osw = new OutputStreamWriter(fos, "ISO-8859-1");
582 assertNotNull(osw);
583
584 osw.write(readLine, 0, readLine.length());
585 osw.flush();
586 fos.flush();
587 osw.close();
588 fos.close();
589
590 FileInputStream fis = new FileInputStream(myFile);
591 assertNotNull(fis);
592
593 InputStreamReader myReader = new InputStreamReader(fis, "ISO-8859-1");
594 assertNotNull(myReader);
595
596 List fieldNames = Arrays.asList(fields);
597
598 DataStreamParser p = new CSVParser(myReader, fieldNames, null);
599
600 assertTrue(p.hasNext());
601
602 ValueParser vp = (ValueParser) p.next();
603
604 assertEquals("Wrong character encoding set", myReader.getEncoding(), vp.getCharacterEncoding());
605
606 assertFalse(p.hasNext());
607
608 for (int i = 0; i < fields.length; i ++)
609 {
610 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
611 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
612 }
613 }
614
615 public void testSetColumnNames()
616 {
617 String readLine = "0,1,2,3,4,5,6,7,8,9\n";
618
619 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
620 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
621
622 Reader myReader = new StringReader(readLine);
623
624 DataStreamParser p = new CSVParser(myReader, null, null);
625
626 assertTrue(p.hasNext());
627
628 p.setColumnNames(Arrays.asList(fields));
629
630 ValueParser vp = (ValueParser) p.next();
631
632 assertEquals("Wrong character encoding set", "US-ASCII", vp.getCharacterEncoding());
633
634 assertFalse(p.hasNext());
635
636 for (int i = 0; i < fields.length; i ++)
637 {
638 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
639 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
640 }
641 }
642
643 public void testEmptyColumnNames()
644 throws Exception
645 {
646 String readLine =
647 "eins,zwei,drei,vier,fuenf,sechs,sieben,acht,neun,null\n"
648 + "0,1,2,3,4,5,6,7,8,9\n";
649
650 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
651
652 Reader myReader = new StringReader(readLine);
653
654 List fieldNames = Arrays.asList(fields);
655
656 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
657
658 assertNotNull(p.getColumnNames());
659 assertEquals("Number of columns is not 0", 0, p.getColumnNames().size());
660
661 p.setColumnNames(fieldNames);
662 assertNotNull(p.getColumnNames());
663 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
664
665 int cnt = 0;
666 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
667 {
668 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
669 }
670 }
671
672 public void testReadColumnNames()
673 throws Exception
674 {
675 String readLine =
676 "eins,zwei,drei,vier,fuenf,sechs,sieben,acht,neun,null\n"
677 + "0,1,2,3,4,5,6,7,8,9\n";
678
679 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
680 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
681
682 Reader myReader = new StringReader(readLine);
683
684 List fieldNames = Arrays.asList(fields);
685
686 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
687
688 assertTrue(p.hasNext());
689
690 p.readColumnNames();
691
692 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
693 int cnt = 0;
694 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
695 {
696 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
697 }
698
699 assertTrue(p.hasNext());
700
701 ValueParser vp = (ValueParser) p.next();
702
703 assertEquals("Wrong character encoding set", "UTF-8", vp.getCharacterEncoding());
704
705 assertFalse(p.hasNext());
706
707 for (int i = 0; i < fields.length; i ++)
708 {
709 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
710 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
711 }
712 }
713
714 public void testJustReadColumnNames()
715 throws Exception
716 {
717 String readLine =
718 "eins,zwei,drei,vier,fuenf,sechs,sieben,acht,neun,null\n";
719
720 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
721
722 Reader myReader = new StringReader(readLine);
723
724 List fieldNames = Arrays.asList(fields);
725
726 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
727
728 assertTrue(p.hasNext());
729
730 p.readColumnNames();
731
732 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
733 int cnt = 0;
734 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
735 {
736 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
737 }
738
739 assertFalse(p.hasNext());
740 }
741
742 public void testJustReadColumnNamesEOF()
743 throws Exception
744 {
745 String readLine =
746 "eins,zwei,drei,vier,fuenf,sechs,sieben,acht,neun,null";
747
748 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
749
750 Reader myReader = new StringReader(readLine);
751
752 List fieldNames = Arrays.asList(fields);
753
754 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
755
756 assertTrue(p.hasNext());
757
758 p.readColumnNames();
759
760 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
761 int cnt = 0;
762 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
763 {
764 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
765 }
766
767 assertFalse(p.hasNext());
768 }
769
770 public void testJustReadColumnNamesQuoted()
771 throws Exception
772 {
773 String readLine =
774 "\"eins\",\"zwei\",\"drei\",\"vier\",\"fuenf\",\"sechs\",\"sieben\",\"acht\",\"neun\",\"null\"\n";
775
776 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
777
778 Reader myReader = new StringReader(readLine);
779
780 List fieldNames = Arrays.asList(fields);
781
782 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
783
784 assertTrue(p.hasNext());
785
786 p.readColumnNames();
787
788 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
789 int cnt = 0;
790 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
791 {
792 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
793 }
794
795 assertFalse(p.hasNext());
796 }
797
798 public void testJustReadColumnNamesQuotedEOF()
799 throws Exception
800 {
801 String readLine =
802 "\"eins\",\"zwei\",\"drei\",\"vier\",\"fuenf\",\"sechs\",\"sieben\",\"acht\",\"neun\",\"null\"";
803
804 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
805
806 Reader myReader = new StringReader(readLine);
807
808 List fieldNames = Arrays.asList(fields);
809
810 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
811
812 assertTrue(p.hasNext());
813
814 p.readColumnNames();
815
816 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
817 int cnt = 0;
818 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
819 {
820 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
821 }
822
823 assertFalse(p.hasNext());
824 }
825 public void testJustReadColumnNamesQuotedMissing()
826 throws Exception
827 {
828 String readLine =
829 "\"eins\",\"zwei\",\"drei\",\"vier\",\"fuenf\",\"sechs\",\"sieben\",\"acht\",\"neun\",\"null\n";
830
831 String [] fields = { "eins", "zwei", "drei", "vier", "fuenf", "sechs", "sieben", "acht", "neun", "null", };
832
833 Reader myReader = new StringReader(readLine);
834
835 List fieldNames = Arrays.asList(fields);
836
837 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
838
839 assertTrue(p.hasNext());
840
841 p.readColumnNames();
842
843 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
844 int cnt = 0;
845 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
846 {
847 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
848 }
849
850 assertFalse(p.hasNext());
851 }
852
853 public void testColumnNamesMissing()
854 throws Exception
855 {
856 String readLine =
857 "eins,zwei,drei,vier,,sechs,,acht,neun,\n";
858
859 String [] fields = { "eins", "zwei", "drei", "vier", "UNKNOWNFIELD5", "sechs", "UNKNOWNFIELD7", "acht", "neun", "UNKNOWNFIELD10", };
860
861 Reader myReader = new StringReader(readLine);
862
863 List fieldNames = Arrays.asList(fields);
864
865 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
866
867 assertTrue(p.hasNext());
868
869 p.readColumnNames();
870
871 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
872 int cnt = 0;
873 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
874 {
875 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
876 }
877
878 assertFalse(p.hasNext());
879 }
880
881 public void testAllColumnNamesMissing()
882 throws Exception
883 {
884 String readLine =
885 ",,,\n0,1,2,3,4,5,6,7,8,9\n";
886
887 String [] fields = { "UNKNOWNFIELD1", "UNKNOWNFIELD2", "UNKNOWNFIELD3", "UNKNOWNFIELD4", };
888 int [] values = { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 };
889
890 Reader myReader = new StringReader(readLine);
891
892 List fieldNames = Arrays.asList(fields);
893
894 DataStreamParser p = new CSVParser(myReader, null, "UTF-8");
895
896 assertTrue(p.hasNext());
897
898 p.readColumnNames();
899
900 assertEquals("Number of columns is not the number of set fields", fieldNames.size(), p.getColumnNames().size());
901 int cnt = 0;
902 for (Iterator it = p.getColumnNames().iterator(); it.hasNext(); )
903 {
904 assertEquals("Column name does not match", ((String) it.next()), fields[cnt++]);
905 }
906
907 assertTrue(p.hasNext());
908
909 ValueParser vp = (ValueParser) p.next();
910
911 assertEquals("Wrong character encoding set", "UTF-8", vp.getCharacterEncoding());
912
913 assertFalse(p.hasNext());
914
915 for (int i = 0; i < fields.length; i ++)
916 {
917 assertEquals("Value does not match", Integer.toString(values[i]), vp.getString(fields[i]));
918 assertEquals("Value does not match", values[i], vp.getInt(fields[i]));
919 }
920 }
921
922 }
923