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