| 
					
				 | 
			
			
				@@ -0,0 +1,2091 @@ 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.BufferedReader;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.ByteArrayInputStream;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.ByteArrayOutputStream;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.File;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.FileInputStream;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.FileNotFoundException;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.FileOutputStream;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.IOException;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.InputStreamReader;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.OutputStreamWriter;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.PrintWriter;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.Reader;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.io.Writer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.lang.reflect.Method;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.lang.reflect.Modifier;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.nio.ByteBuffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.nio.charset.Charset;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import java.util.ArrayList;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import org.junit.After;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import org.junit.Assert;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import org.junit.Before;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import org.junit.Ignore;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import org.junit.Test;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import com.csvreader.CsvReader;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+import com.csvreader.CsvWriter;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+public class AllTests {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("rawtypes")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public static void main(String[] args) throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Class testClass = AllTests.class;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ArrayList<Method> setups = new ArrayList<Method>();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ArrayList<Method> tearDowns = new ArrayList<Method>();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (Method method : testClass.getDeclaredMethods()) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      int modifiers = method.getModifiers();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      if (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) && method.getAnnotation(Ignore.class) == null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        if (method.getAnnotation(Before.class) != null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          setups.add(method);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        if (method.getAnnotation(After.class) != null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          setups.add(method);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    System.out.println("Starting all tests.");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Object instance = testClass.newInstance();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (Method method : testClass.getDeclaredMethods()) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      int modifiers = method.getModifiers();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      if (Modifier.isPublic(modifiers) && !Modifier.isStatic(modifiers) && method.getAnnotation(Ignore.class) == null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        Test testAnnotation = method.getAnnotation(Test.class);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        if (testAnnotation != null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          for (Method setup : setups) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            setup.invoke(instance, (Object[]) null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          Class expectedException = testAnnotation.expected();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          // can't for the life of me get eclipse to be able to
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          // resolve Test.None directly
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          if (expectedException.getName().equals("org.junit.Test$None")) // why
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                                                                         // the
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                                                                         // hell
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                                                                         // doesn't
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                                                                         // this
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          // just return null?
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            expectedException = null;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            method.invoke(instance, (Object[]) null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          } catch (Exception e) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            if (expectedException == null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              System.out.println(testClass.getName() + "." + method.getName() + ": " + e.getCause().getMessage());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              new BufferedReader(new InputStreamReader(System.in)).readLine();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            } else {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              // is there a cleaner way of saying this?
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              if (!e.getCause().getClass().equals(testAnnotation.expected())) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                System.out.println(testClass.getName() + "." + method.getName() + ": " + "Exception expected: "
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                    + testAnnotation.expected().getName() + ", Exception thrown: " + e.getCause().getMessage());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                new BufferedReader(new InputStreamReader(System.in)).readLine();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              expectedException = null;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          if (expectedException != null) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            System.out.println(testClass.getName() + "." + method.getName() + ": " + "Expected exception not thrown: "
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+                + testAnnotation.expected().getName());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            new BufferedReader(new InputStreamReader(System.in)).readLine();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          for (Method tearDown : tearDowns) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            tearDown.invoke(instance, (Object[]) null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        } // end if (testAnnotation != null)
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      } // end if (Modifier.isPublic(modifiers)...
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } // end for (Method method : testClass.getDeclaredMethods())
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    System.out.println("Done with all tests.");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  private static String generateString(char letter, int count) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    StringBuffer buffer = new StringBuffer(count);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (int i = 0; i < count; i++) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      buffer.append(letter);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    return buffer.toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  private static void assertException(Exception expected, Exception actual) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(expected.getClass(), actual.getClass());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(expected.getMessage(), actual.getMessage());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test1() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', reader.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test2() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"bob said, \"\"Hey!\"\"\",2, 3 ";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("bob said, \"Hey!\"", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("3", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', reader.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"bob said, \"\"Hey!\"\"\",2, 3 ", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test3() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = ",";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', reader.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(",", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test4() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r2";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test5() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\n2";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test6() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n2";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test7() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test8() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test9() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test10() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r2\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setDelimiter('\r');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\r2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test11() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"July 4th, 2005\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("July 4th, 2005", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"July 4th, 2005\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test12() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = " 1";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setTrimWhitespace(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(" 1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(" 1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test13() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test14() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "user_id,name\r\n1,Bruce";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readHeaders());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("user_id,name", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Bruce", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0, reader.getIndex("user_id"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getIndex("name"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("user_id", reader.getHeader(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("name", reader.getHeader(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get("user_id"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Bruce", reader.get("name"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,Bruce", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test15() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"data \r\n here\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("data \r\n here", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"data \r\n here\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test16() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\r\r\n1\r";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setDelimiter('\r');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\r\r", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\r", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test17() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"double\"\"\"\"double quotes\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("double\"\"double quotes", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"double\"\"\"\"double quotes\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test18() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test19() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test20() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test21() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "'bob said, ''Hey!''',2, 3 ";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setTextQualifier('\'');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("bob said, 'Hey!'", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("3", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', reader.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("'bob said, ''Hey!''',2, 3 ", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test22() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"data \"\" here\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"data \"\" here\"", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"data \"\" here\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test23() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = generateString('a', 75) + "," + generateString('b', 75);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(reader.get(0), generateString('a', 75));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(reader.get(1), generateString('b', 75));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 75) + "," + generateString('b', 75), reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test24() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n\r\n1";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test25() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n# bunch of crazy stuff here\r\n1";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseComments(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test26() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"Mac \"The Knife\" Peter\",\"Boswell, Jr.\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Mac ", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Boswell, Jr.", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"Mac \"The Knife\" Peter\",\"Boswell, Jr.\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test27() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"1\",Bruce\r\n\"2\n\",Toni\r\n\"3\",Brian\r\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Bruce", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"1\",Bruce", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.skipRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"2\n\",Toni", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("3", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Brian", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"3\",Brian", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test28() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"bob said, \\\"Hey!\\\"\",2, 3 ";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("bob said, \"Hey!\"", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("3", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', reader.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"bob said, \\\"Hey!\\\"\",2, 3 ", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test29() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"double\\\"\\\"double quotes\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("double\"\"double quotes", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"double\\\"\\\"double quotes\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test30() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"double\\\\\\\\double backslash\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("double\\\\double backslash", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"double\\\\\\\\double backslash\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test31() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(new PrintWriter(new OutputStreamWriter(new FileOutputStream("temp.csv"),
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        Charset.forName("UTF-8"))), ',');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // writer will trim all whitespace and put this in quotes to preserve
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // it's existance
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(" \t \t");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(new InputStreamReader(new FileInputStream("temp.csv"), Charset.forName("UTF-8")));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    new File("temp.csv").delete();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test32() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"Mac \"The Knife\" Peter\",\"Boswell, Jr.\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Mac ", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Boswell, Jr.", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"Mac \"The Knife\" Peter\",\"Boswell, Jr.\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test33() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // tests for an old bug where an exception was
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // thrown if Dispose was called without other methods
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // being called. this should not throw an
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // exception
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String fileName = "somefile.csv";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    new File(fileName).createNewFile();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader reader = new CsvReader(fileName);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } finally {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      new File(fileName).delete();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test34() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"Chicane\", \"Love on the Run\", \"Knight Rider\", \"This field contains a comma, but it doesn't matter as the field is quoted\"\r\n"
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        + "\"Samuel Barber\", \"Adagio for Strings\", \"Classical\", \"This field contains a double quote character, \"\", but it doesn't matter as it is escaped\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a comma, but it doesn't matter as the field is quoted", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "\"Chicane\", \"Love on the Run\", \"Knight Rider\", \"This field contains a comma, but it doesn't matter as the field is quoted\"",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Samuel Barber", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Adagio for Strings", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Classical", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a double quote character, \", but it doesn't matter as it is escaped",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "\"Samuel Barber\", \"Adagio for Strings\", \"Classical\", \"This field contains a double quote character, \"\", but it doesn't matter as it is escaped\"",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test35() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "Chicane, Love on the Run, Knight Rider, \"This field contains a comma, but it doesn't matter as the field is quoted\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a comma, but it doesn't matter as the field is quoted", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "Chicane, Love on the Run, Knight Rider, \"This field contains a comma, but it doesn't matter as the field is quoted\"",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test36() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"some \\stuff\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("some stuff", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"some \\stuff\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test37() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "  \" Chicane\"  junk here  , Love on the Run, Knight Rider, \"This field contains a comma, but it doesn't matter as the field is quoted\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(" Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a comma, but it doesn't matter as the field is quoted", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "  \" Chicane\"  junk here  , Love on the Run, Knight Rider, \"This field contains a comma, but it doesn't matter as the field is quoted\"",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test38() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "1\r\n\r\n\"\"\r\n \r\n2";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(" ", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test39() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("user_id,name\r\n1,Bruce");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getSafetySwitch());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSafetySwitch(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getSafetySwitch());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('#', reader.getComment());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setComment('!');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('!', reader.getComment());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(CsvReader.ESCAPE_MODE_DOUBLED, reader.getEscapeMode());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(CsvReader.ESCAPE_MODE_BACKSLASH, reader.getEscapeMode());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\0', reader.getRecordDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(';', reader.getRecordDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\"', reader.getTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setTextQualifier('\'');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\'', reader.getTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getTrimWhitespace());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setTrimWhitespace(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getTrimWhitespace());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getUseComments());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseComments(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getUseComments());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getUseTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getUseTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test40() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "Chicane, Love on the Run, Knight Rider, This field contains a comma\\, but it doesn't matter as the delimiter is escaped";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals("This field contains a comma, but it doesn't matter as the delimiter is escaped", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "Chicane, Love on the Run, Knight Rider, This field contains a comma\\, but it doesn't matter as the delimiter is escaped",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test41() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "double\\\\\\\\double backslash";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("double\\\\double backslash", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test42() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "some \\stuff";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("some stuff", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test43() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"line 1\\nline 2\",\"line 1\\\nline 2\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("line 1\nline 2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("line 1\nline 2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test44() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "line 1\\nline 2,line 1\\\nline 2";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("line 1\nline 2", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("line 1\nline 2", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test45() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"Chicane\", \"Love on the Run\", \"Knight Rider\", \"This field contains a comma, but it doesn't matter as the field is quoted\"i"
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        + "\"Samuel Barber\", \"Adagio for Strings\", \"Classical\", \"This field contains a double quote character, \"\", but it doesn't matter as it is escaped\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getCaptureRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setCaptureRawRecord(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getCaptureRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setRecordDelimiter('i');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a comma, but it doesn't matter as the field is quoted", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getCaptureRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setCaptureRawRecord(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getCaptureRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        .assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            "\"Samuel Barber\", \"Adagio for Strings\", \"Classical\", \"This field contains a double quote character, \"\", but it doesn't matter as it is escaped\"",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+            reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Samuel Barber", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Adagio for Strings", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Classical", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a double quote character, \", but it doesn't matter as it is escaped",
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getCaptureRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test46() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "Ch\\icane, Love on the Run, Kn\\ight R\\ider, Th\\is f\\ield conta\\ins an \\i\\, but \\it doesn't matter as \\it \\is escapedi"
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        + "Samuel Barber, Adag\\io for Str\\ings, Class\\ical, Th\\is f\\ield conta\\ins a comma \\, but \\it doesn't matter as \\it \\is escaped";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setRecordDelimiter('i');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Chicane", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Love on the Run", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Knight Rider", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains an i, but it doesn't matter as it is escaped", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Samuel Barber", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Adagio for Strings", reader.get(1));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Classical", reader.get(2));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("This field contains a comma , but it doesn't matter as it is escaped", reader.get(3));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test47() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String test = "M�nchen";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    PrintWriter writer = new PrintWriter(new OutputStreamWriter(stream, Charset.forName("UTF-8")));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.println(test);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(new InputStreamReader(new ByteArrayInputStream(buffer), Charset.forName("UTF-8")));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(test, reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test48() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String test = "M�nchen";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    PrintWriter writer = new PrintWriter(new OutputStreamWriter(stream, Charset.forName("UTF-8")));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(test);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(new InputStreamReader(new ByteArrayInputStream(buffer), Charset.forName("UTF-8")));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(test, reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test49() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"\\n\\r\\t\\b\\f\\e\\v\\a\\z\\d065\\o101\\101\\x41\\u0041\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\n\r\t\b\f\u001B\u000B\u0007zAAAAA", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"\\n\\r\\t\\b\\f\\e\\v\\a\\z\\d065\\o101\\101\\x41\\u0041\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test50() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\\n\\r\\t\\b\\f\\e\\v\\a\\z\\d065\\o101\\101\\x41\\u0041";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\n\r\t\b\f\u001B\u000B\u0007zAAAAA", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\\n\\r\\t\\b\\f\\e\\v\\a\\z\\d065\\o101\\101\\x41\\u0041", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test51() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"\\xfa\\u0afa\\xFA\\u0AFA\"";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\u00FA\u0AFA\u00FA\u0AFA", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"\\xfa\\u0afa\\xFA\\u0AFA\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test52() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\\xfa\\u0afa\\xFA\\u0AFA";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\u00FA\u0AFA\u00FA\u0AFA", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\\xfa\\u0afa\\xFA\\u0AFA", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test54() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(writer.getForceQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setForceQualifier(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(writer.getForceQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        "\"1,2\",3,\"blah \"\"some stuff in quotes\"\"\"\r\n\"1,2\",\"3\",\"blah \"\"some stuff in quotes\"\"\"", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test55() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"\",1", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test56() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, '\t', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,2\t3\t\"blah \"\"some stuff in quotes\"\"\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test57() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, '\t', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(writer.getUseTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(writer.getUseTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,2\t3\tblah \"some stuff in quotes\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test58() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, '\t', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("data\r\nmore data");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(" 3\t", false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(" 3\t");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(" 3\t", true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"data\r\nmore data\"\t3\t3\t\" 3\t\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test70() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = "\"1\",Bruce\r\n\"2\",Toni\r\n\"3\",Brian\r\n";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setHeaders(new String[] { "userid", "name" });
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getHeaderCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get("userid"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Bruce", reader.get("name"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("2", reader.get("userid"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Toni", reader.get("name"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("3", reader.get("userid"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("Brian", reader.get("name"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test71() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setForceQualifier(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(" data ");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"data\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test72() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\0', writer.getRecordDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(';', writer.getRecordDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("a;b");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"a;b\";", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test73() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(CsvWriter.ESCAPE_MODE_DOUBLED, writer.getEscapeMode());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(CsvWriter.ESCAPE_MODE_BACKSLASH, writer.getEscapeMode());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setForceQualifier(true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+        "\"1,2\",3,\"blah \\\"some stuff in quotes\\\"\"\r\n\"1,2\",\"3\",\"blah \\\"some stuff in quotes\\\"\"", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test74() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\\,2,3,blah \"some stuff in quotes\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test75() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeComment("blah");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\r\n#blah\r\n2\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test76() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("user_id,name\r\n1,Bruce");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertNull(reader.getHeaders());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(-1, reader.getIndex("user_id"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getHeader(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readHeaders());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0, reader.getIndex("user_id"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("user_id", reader.getHeader(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String[] headers = reader.getHeaders();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2, headers.length);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("user_id", headers[0]);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("name", headers[1]);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setHeaders(null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertNull(reader.getHeaders());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(-1, reader.getIndex("user_id"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getHeader(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test77() {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader.parse(null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter data can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test78() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1,Bruce");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.isQualified(999));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test79() {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader = CsvReader.parse("");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IOException("This instance of the CsvReader class has already been closed."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test81() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(generateString('a', 100001));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          new IOException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              "Maximum column length of 100,000 exceeded in column 0 in record 0. Set the SafetySwitch property to false if you're expecting column lengths greater than 100,000 characters to avoid this error."),
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test82() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    StringBuilder holder = new StringBuilder(200010);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (int i = 0; i < 100000; i++) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      holder.append("a,");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    holder.append("a");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(holder.toString());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          new IOException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              "Maximum column count of 100,000 exceeded in record 0. Set the SafetySwitch property to false if you're expecting more than 100,000 columns per record to avoid this error."),
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test83() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(generateString('a', 100001));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSafetySwitch(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test84() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    StringBuilder holder = new StringBuilder(200010);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (int i = 0; i < 100000; i++) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      holder.append("a,");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    holder.append("a");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(holder.toString());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSafetySwitch(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test85() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(generateString('a', 100000));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test86() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    StringBuilder holder = new StringBuilder(200010);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (int i = 0; i < 99999; i++) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      holder.append("a,");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    holder.append("a");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(holder.toString());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test87() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter("temp.csv");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader("temp.csv");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    new File("temp.csv").delete();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test88() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader reader = new CsvReader((String) null, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter fileName can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test89() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader reader = new CsvReader("temp.csv", ',', null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter charset can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test90() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader reader = new CsvReader((Reader) null, ',');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter inputStream can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test91() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String test = "test";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    PrintWriter writer = new PrintWriter(stream);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.println(test);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(new ByteArrayInputStream(buffer), Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(test, reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test92() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String test = "test";
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    PrintWriter writer = new PrintWriter(stream);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.println(test);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(new ByteArrayInputStream(buffer), ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(test, reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test112() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvWriter writer = new CsvWriter((String) null, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter fileName can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test113() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvWriter writer = new CsvWriter("test.csv", ',', (Charset) null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter charset can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test114() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvWriter writer = new CsvWriter((Writer) null, ',');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IllegalArgumentException("Parameter outputStream can not be null."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test115() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvWriter writer = new CsvWriter("test.csv");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      writer.write("");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IOException("This instance of the CsvWriter class has already been closed."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test117() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('#', writer.getComment());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setComment('~');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('~', writer.getComment());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeComment("blah");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1;~blah;", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test118() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, '\t', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\"', writer.getTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setTextQualifier('\'');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\'', writer.getTextQualifier());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \"some stuff in quotes\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("blah \'some stuff in quotes\'");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,2\t3\tblah \"some stuff in quotes\"\t\'blah \'\'some stuff in quotes\'\'\'\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test119() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(',', writer.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setDelimiter('\t');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals('\t', writer.getDelimiter());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"1,2\",3\r\n1,2\t3\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test120() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.flush(); // testing that flush flushed to stream
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"1,2\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test121() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeRecord(new String[] { " 1 ", "2" }, false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeRecord(new String[] { " 1 ", "2" });
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeRecord(new String[] { " 1 ", "2" }, true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeRecord(new String[0], true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.writeRecord(null, true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1,2\r\n1,2\r\n\" 1 \",2\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test122() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write(null);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("3 ", true);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"1,2\",,\"3 \"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test123() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("#123");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("#123");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("#");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"#123\"\r\n\\#123\r\n\\#\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test124() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1;2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\\;2;", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test131() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,\\\r\n2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,\\;2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1\\,\\\\\\\r\\\n2\r\n1\\,\\\\\\;2;", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test132() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    byte[] buffer;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    ByteArrayOutputStream stream = new ByteArrayOutputStream();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvWriter writer = new CsvWriter(stream, ',', Charset.forName("ISO-8859-1"));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.setEscapeMode(CsvWriter.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.write("1,\\2");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.endRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    writer.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    buffer = stream.toByteArray();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    stream.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    String data = Charset.forName("ISO-8859-1").decode(ByteBuffer.wrap(buffer)).toString();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"1,\\\\2\"\r\n", data);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test135() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1\n\n1\r\r1\r\n\r\n1\n\r1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSkipEmptyRecords(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(5L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(6L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(7L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(8L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test136() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1\n\n1\r\r1\r\n\r\n1\n\r1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(4L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test137() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1;; ;1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSkipEmptyRecords(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(3L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test138() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("1;; ;1");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setRecordDelimiter(';');
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.getSkipEmptyRecords());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(0L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(1, reader.getColumnCount());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("1", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(2L, reader.getCurrentRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test143() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("\"" + generateString('a', 100001) + "\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          new IOException(
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+              "Maximum column length of 100,000 exceeded in column 0 in record 0. Set the SafetySwitch property to false if you're expecting column lengths greater than 100,000 characters to avoid this error."),
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+          ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test144() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("\"" + generateString('a', 100000) + "\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 100000), reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"" + generateString('a', 100000) + "\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test145() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("\"" + generateString('a', 100001) + "\"");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setSafetySwitch(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 100001), reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test146() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // testing SkipLine's buffer
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("\"" + generateString('a', 10000) + "\r\nb");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.skipLine());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("b", reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test147() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // testing AppendLetter's buffer
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    StringBuilder data = new StringBuilder(20000);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    for (int i = 0; i < 10000; i++) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      data.append("\\b");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse(data.toString());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setUseTextQualifier(false);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.setEscapeMode(CsvReader.ESCAPE_MODE_BACKSLASH);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('\b', 10000), reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test148() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // testing a specific case in GetRawRecord where the result is what's in
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // the data buffer
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // plus what's in the raw buffer
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = CsvReader.parse("\"" + generateString('a', 100000) + "\"\r\n" + generateString('a', 100000));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 100000), reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals("\"" + generateString('a', 100000) + "\"", reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 100000), reader.get(0));
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertEquals(generateString('a', 100000), reader.getRawRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(reader.readRecord());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @SuppressWarnings("unused")
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test149() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      CsvReader reader = new CsvReader("C:\\somefilethatdoesntexist.csv");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new FileNotFoundException("File C:\\somefilethatdoesntexist.csv does not exist."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  @Test
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  public void test173() throws Exception {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    FailingReader fail = new FailingReader();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    CsvReader reader = new CsvReader(fail);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    boolean exceptionThrown = false;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertFalse(fail.DisposeCalled);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      // need to test IO exception block logic while trying to read
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.readRecord();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (IOException ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      // make sure stream that caused exception
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      // has been sent a dipose call
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      Assert.assertTrue(fail.DisposeCalled);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      exceptionThrown = true;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      Assert.assertEquals("Read failed.", ex.getMessage());
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } finally {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.close();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    Assert.assertTrue(exceptionThrown);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // test to make sure object has been marked
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    // internally as disposed
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    try {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      reader.getHeaders();
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    } catch (Exception ex) {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      assertException(new IOException("This instance of the CsvReader class has already been closed."), ex);
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  private class FailingReader extends Reader {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    public boolean DisposeCalled = false;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    public FailingReader() {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      super("");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    public int read(char[] buffer, int index, int count) throws IOException {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      throw new IOException("Read failed.");
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    public void close() {
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+      DisposeCalled = true;
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+    }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+  }
 
			 | 
		
	
		
			
				 | 
				 | 
			
			
				+}
 
			 |