1   package org.apache.turbine.util.parser;
2   
3   /*
4    * Copyright 2001-2005 The Apache Software Foundation.
5    *
6    * Licensed under the Apache License, Version 2.0 (the "License")
7    * you may not use this file except in compliance with the License.
8    * You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
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