424 lines
22 KiB
Java
424 lines
22 KiB
Java
/*
|
|
* Copyright (C) 2013 The Android Open Source Project
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
package com.android.inputmethod.latin.utils;
|
|
|
|
import android.test.AndroidTestCase;
|
|
import android.test.suitebuilder.annotation.SmallTest;
|
|
|
|
import com.android.inputmethod.latin.utils.CsvUtils.CsvParseException;
|
|
|
|
import java.util.Arrays;
|
|
|
|
@SmallTest
|
|
public class CsvUtilsTests extends AndroidTestCase {
|
|
public void testUnescape() {
|
|
assertEquals("", CsvUtils.unescapeField(""));
|
|
assertEquals("text", CsvUtils.unescapeField("text")); // text
|
|
assertEquals("", CsvUtils.unescapeField("\"\"")); // ""
|
|
assertEquals("\"", CsvUtils.unescapeField("\"\"\"\"")); // """" -> "
|
|
assertEquals("text", CsvUtils.unescapeField("\"text\"")); // "text" -> text
|
|
assertEquals("\"text", CsvUtils.unescapeField("\"\"\"text\"")); // """text" -> "text
|
|
assertEquals("text\"", CsvUtils.unescapeField("\"text\"\"\"")); // "text""" -> text"
|
|
assertEquals("te\"xt", CsvUtils.unescapeField("\"te\"\"xt\"")); // "te""xt" -> te"xt
|
|
assertEquals("\"text\"",
|
|
CsvUtils.unescapeField("\"\"\"text\"\"\"")); // """text""" -> "text"
|
|
assertEquals("t\"e\"x\"t",
|
|
CsvUtils.unescapeField("\"t\"\"e\"\"x\"\"t\"")); // "t""e""x""t" -> t"e"x"t
|
|
}
|
|
|
|
public void testUnescapeException() {
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\""); // "
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"\"\""); // """
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"\"\"\"\""); // """""
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"text"); // "text
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("text\""); // text"
|
|
fail("Raw quote in text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("te\"xt"); // te"xt
|
|
fail("Raw quote in text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"\"text"); // ""text
|
|
fail("Raw quote in quoted text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("text\"\""); // text""
|
|
fail("Escaped quote in text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Escaped quote in text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("te\"\"xt"); // te""xt
|
|
fail("Escaped quote in text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Escaped quote in text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"\"text\""); // ""text"
|
|
fail("Raw quote in quoted text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"text\"\""); // "text""
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"te\"xt\""); // "te"xt"
|
|
fail("Raw quote in quoted text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\"b,c"); // "b,c
|
|
fail("Unterminated quote: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String text = CsvUtils.unescapeField("\",\"a\""); // ","a"
|
|
fail("Raw quote in quoted text: text=" + text);
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
}
|
|
|
|
private static <T> void assertArrayEquals(final T[] expected, final T[] actual) {
|
|
if (expected == actual) {
|
|
return;
|
|
}
|
|
if (expected == null || actual == null) {
|
|
assertEquals(Arrays.toString(expected), Arrays.toString(actual));
|
|
return;
|
|
}
|
|
if (expected.length != actual.length) {
|
|
assertEquals("[length]", Arrays.toString(expected), Arrays.toString(actual));
|
|
return;
|
|
}
|
|
for (int i = 0; i < expected.length; i++) {
|
|
final T e = expected[i];
|
|
final T a = actual[i];
|
|
if (e == a) {
|
|
continue;
|
|
}
|
|
assertEquals("["+i+"]", expected[i], actual[i]);
|
|
}
|
|
}
|
|
|
|
public void testSplit() {
|
|
assertArrayEquals(new String[]{""}, CsvUtils.split(""));
|
|
assertArrayEquals(new String[]{" "}, CsvUtils.split(" "));
|
|
assertArrayEquals(new String[]{"text"}, CsvUtils.split("text"));
|
|
assertArrayEquals(new String[]{" a b "}, CsvUtils.split(" a b "));
|
|
|
|
assertArrayEquals(new String[]{"", ""}, CsvUtils.split(","));
|
|
assertArrayEquals(new String[]{"", "", ""}, CsvUtils.split(",,"));
|
|
assertArrayEquals(new String[]{" ", " "}, CsvUtils.split(" , "));
|
|
assertArrayEquals(new String[]{" ", " ", " "}, CsvUtils.split(" , , "));
|
|
assertArrayEquals(new String[]{"a", "b"}, CsvUtils.split("a,b"));
|
|
assertArrayEquals(new String[]{" a ", " b "}, CsvUtils.split(" a , b "));
|
|
|
|
assertArrayEquals(new String[]{"text"},
|
|
CsvUtils.split("\"text\"")); // "text"
|
|
assertArrayEquals(new String[]{" text "},
|
|
CsvUtils.split("\" text \"")); // "_text_"
|
|
|
|
assertArrayEquals(new String[]{""},
|
|
CsvUtils.split("\"\"")); // ""
|
|
assertArrayEquals(new String[]{"\""},
|
|
CsvUtils.split("\"\"\"\"")); // """"
|
|
assertArrayEquals(new String[]{"", ""},
|
|
CsvUtils.split("\"\",\"\"")); // "",""
|
|
assertArrayEquals(new String[]{"\",\""},
|
|
CsvUtils.split("\"\"\",\"\"\"")); // ""","""
|
|
assertArrayEquals(new String[]{"\"", "\""},
|
|
CsvUtils.split("\"\"\"\",\"\"\"\"")); // """",""""
|
|
assertArrayEquals(new String[]{"\"", "\",\""},
|
|
CsvUtils.split("\"\"\"\",\"\"\",\"\"\"")); // """",""","""
|
|
assertArrayEquals(new String[]{"\",\"", "\""},
|
|
CsvUtils.split("\"\"\",\"\"\",\"\"\"\"")); // """,""",""""
|
|
|
|
assertArrayEquals(new String[]{" a ", " b , c "},
|
|
CsvUtils.split(" a ,\" b , c \"")); // _a_,"_b_,_c_"
|
|
assertArrayEquals(new String[]{" a ", " b , c ", " d "},
|
|
CsvUtils.split(" a ,\" b , c \", d ")); // _a_,"_b_,_c_",_d_
|
|
}
|
|
|
|
public void testSplitException() {
|
|
try {
|
|
final String[] fields = CsvUtils.split(" \"text\" "); // _"text"_
|
|
fail("Raw quote in text: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in text", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split(" \" text \" "); // _"_text_"_
|
|
fail("Raw quote in text: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in text", success.getMessage());
|
|
}
|
|
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\"b,"); // a,",b
|
|
fail("Unterminated quote: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\"\"\",b"); // a,""",b
|
|
fail("Unterminated quote: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\"\"\"\"\",b"); // a,""""",b
|
|
fail("Unterminated quote: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\"b,c"); // a,"b,c
|
|
fail("Unterminated quote: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Unterminated quote", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\",\"b,c"); // a,","b,c
|
|
fail("Raw quote in quoted text: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
try {
|
|
final String[] fields = CsvUtils.split("a,\",\"b\",\",c"); // a,","b",",c
|
|
fail("Raw quote in quoted text: fields=" + Arrays.toString(fields));
|
|
} catch (final CsvParseException success) {
|
|
assertEquals("Raw quote in quoted text", success.getMessage());
|
|
}
|
|
}
|
|
|
|
public void testSplitWithTrimSpaces() {
|
|
final int trimSpaces = CsvUtils.SPLIT_FLAGS_TRIM_SPACES;
|
|
assertArrayEquals(new String[]{""}, CsvUtils.split(trimSpaces, ""));
|
|
assertArrayEquals(new String[]{""}, CsvUtils.split(trimSpaces, " "));
|
|
assertArrayEquals(new String[]{"text"}, CsvUtils.split(trimSpaces, "text"));
|
|
assertArrayEquals(new String[]{"a b"}, CsvUtils.split(trimSpaces, " a b "));
|
|
|
|
assertArrayEquals(new String[]{"", ""}, CsvUtils.split(trimSpaces, ","));
|
|
assertArrayEquals(new String[]{"", "", ""}, CsvUtils.split(trimSpaces, ",,"));
|
|
assertArrayEquals(new String[]{"", ""}, CsvUtils.split(trimSpaces, " , "));
|
|
assertArrayEquals(new String[]{"", "", ""}, CsvUtils.split(trimSpaces, " , , "));
|
|
assertArrayEquals(new String[]{"a", "b"}, CsvUtils.split(trimSpaces, "a,b"));
|
|
assertArrayEquals(new String[]{"a", "b"}, CsvUtils.split(trimSpaces, " a , b "));
|
|
|
|
assertArrayEquals(new String[]{"text"},
|
|
CsvUtils.split(trimSpaces, "\"text\"")); // "text"
|
|
assertArrayEquals(new String[]{"text"},
|
|
CsvUtils.split(trimSpaces, " \"text\" ")); // _"text"_
|
|
assertArrayEquals(new String[]{" text "},
|
|
CsvUtils.split(trimSpaces, "\" text \"")); // "_text_"
|
|
assertArrayEquals(new String[]{" text "},
|
|
CsvUtils.split(trimSpaces, " \" text \" ")); // _"_text_"_
|
|
assertArrayEquals(new String[]{"a", "b"},
|
|
CsvUtils.split(trimSpaces, " \"a\" , \"b\" ")); // _"a"_,_"b"_
|
|
|
|
assertArrayEquals(new String[]{""},
|
|
CsvUtils.split(trimSpaces, " \"\" ")); // _""_
|
|
assertArrayEquals(new String[]{"\""},
|
|
CsvUtils.split(trimSpaces, " \"\"\"\" ")); // _""""_
|
|
assertArrayEquals(new String[]{"", ""},
|
|
CsvUtils.split(trimSpaces, " \"\" , \"\" ")); // _""_,_""_
|
|
assertArrayEquals(new String[]{"\" , \""},
|
|
CsvUtils.split(trimSpaces, " \"\"\" , \"\"\" ")); // _"""_,_"""_
|
|
assertArrayEquals(new String[]{"\"", "\""},
|
|
CsvUtils.split(trimSpaces, " \"\"\"\" , \"\"\"\" ")); // _""""_,_""""_
|
|
assertArrayEquals(new String[]{"\"", "\" , \""},
|
|
CsvUtils.split(trimSpaces, " \"\"\"\" , \"\"\" , \"\"\" ")); // _""""_,_"""_,_"""_
|
|
assertArrayEquals(new String[]{"\" , \"", "\""},
|
|
CsvUtils.split(trimSpaces, " \"\"\" , \"\"\" , \"\"\"\" ")); // _"""_,_"""_,_""""_
|
|
|
|
assertArrayEquals(new String[]{"a", " b , c "},
|
|
CsvUtils.split(trimSpaces, " a , \" b , c \" ")); // _a_,_"_b_,_c_"_
|
|
assertArrayEquals(new String[]{"a", " b , c ", "d"},
|
|
CsvUtils.split(trimSpaces, " a, \" b , c \" , d ")); // _a,_"_b_,_c_"_,_d_
|
|
}
|
|
|
|
public void testEscape() {
|
|
assertEquals("", CsvUtils.escapeField("", false));
|
|
assertEquals("plain", CsvUtils.escapeField("plain", false));
|
|
assertEquals(" ", CsvUtils.escapeField(" ", false));
|
|
assertEquals(" ", CsvUtils.escapeField(" ", false));
|
|
assertEquals("a space", CsvUtils.escapeField("a space", false));
|
|
assertEquals(" space-at-start", CsvUtils.escapeField(" space-at-start", false));
|
|
assertEquals("space-at-end ", CsvUtils.escapeField("space-at-end ", false));
|
|
assertEquals("a lot of spaces", CsvUtils.escapeField("a lot of spaces", false));
|
|
assertEquals("\",\"", CsvUtils.escapeField(",", false));
|
|
assertEquals("\",,\"", CsvUtils.escapeField(",,", false));
|
|
assertEquals("\"a,comma\"", CsvUtils.escapeField("a,comma", false));
|
|
assertEquals("\",comma-at-begin\"", CsvUtils.escapeField(",comma-at-begin", false));
|
|
assertEquals("\"comma-at-end,\"", CsvUtils.escapeField("comma-at-end,", false));
|
|
assertEquals("\",,a,lot,,,of,commas,,\"",
|
|
CsvUtils.escapeField(",,a,lot,,,of,commas,,", false));
|
|
assertEquals("\"a comma,and a space\"", CsvUtils.escapeField("a comma,and a space", false));
|
|
assertEquals("\"\"\"\"", CsvUtils.escapeField("\"", false)); // " -> """"
|
|
assertEquals("\"\"\"\"\"\"", CsvUtils.escapeField("\"\"", false)); // "" -> """"""
|
|
assertEquals("\"\"\"\"\"\"\"\"", CsvUtils.escapeField("\"\"\"", false)); // """ -> """"""""
|
|
assertEquals("\"\"\"text\"\"\"",
|
|
CsvUtils.escapeField("\"text\"", false)); // "text" -> """text"""
|
|
assertEquals("\"text has \"\" in middle\"",
|
|
CsvUtils.escapeField("text has \" in middle", false));
|
|
assertEquals("\"\"\"quote,at begin\"", CsvUtils.escapeField("\"quote,at begin", false));
|
|
assertEquals("\"quote at,end\"\"\"", CsvUtils.escapeField("quote at,end\"", false));
|
|
assertEquals("\"\"\"quote at begin\"", CsvUtils.escapeField("\"quote at begin", false));
|
|
assertEquals("\"quote at end\"\"\"", CsvUtils.escapeField("quote at end\"", false));
|
|
}
|
|
|
|
public void testEscapeWithAlwaysQuoted() {
|
|
assertEquals("\"\"", CsvUtils.escapeField("", true));
|
|
assertEquals("\"plain\"", CsvUtils.escapeField("plain", true));
|
|
assertEquals("\" \"", CsvUtils.escapeField(" ", true));
|
|
assertEquals("\" \"", CsvUtils.escapeField(" ", true));
|
|
assertEquals("\"a space\"", CsvUtils.escapeField("a space", true));
|
|
assertEquals("\" space-at-start\"", CsvUtils.escapeField(" space-at-start", true));
|
|
assertEquals("\"space-at-end \"", CsvUtils.escapeField("space-at-end ", true));
|
|
assertEquals("\"a lot of spaces\"", CsvUtils.escapeField("a lot of spaces", true));
|
|
assertEquals("\",\"", CsvUtils.escapeField(",", true));
|
|
assertEquals("\",,\"", CsvUtils.escapeField(",,", true));
|
|
assertEquals("\"a,comma\"", CsvUtils.escapeField("a,comma", true));
|
|
assertEquals("\",comma-at-begin\"", CsvUtils.escapeField(",comma-at-begin", true));
|
|
assertEquals("\"comma-at-end,\"", CsvUtils.escapeField("comma-at-end,", true));
|
|
assertEquals("\",,a,lot,,,of,commas,,\"",
|
|
CsvUtils.escapeField(",,a,lot,,,of,commas,,", true));
|
|
assertEquals("\"a comma,and a space\"", CsvUtils.escapeField("a comma,and a space", true));
|
|
assertEquals("\"\"\"\"", CsvUtils.escapeField("\"", true)); // " -> """"
|
|
assertEquals("\"\"\"\"\"\"", CsvUtils.escapeField("\"\"", true)); // "" -> """"""
|
|
assertEquals("\"\"\"\"\"\"\"\"", CsvUtils.escapeField("\"\"\"", true)); // """ -> """"""""
|
|
assertEquals("\"\"\"text\"\"\"",
|
|
CsvUtils.escapeField("\"text\"", true)); // "text" -> """text"""
|
|
assertEquals("\"text has \"\" in middle\"",
|
|
CsvUtils.escapeField("text has \" in middle", true));
|
|
assertEquals("\"\"\"quote,at begin\"", CsvUtils.escapeField("\"quote,at begin", true));
|
|
assertEquals("\"quote at,end\"\"\"", CsvUtils.escapeField("quote at,end\"", true));
|
|
assertEquals("\"\"\"quote at begin\"", CsvUtils.escapeField("\"quote at begin", true));
|
|
assertEquals("\"quote at end\"\"\"", CsvUtils.escapeField("quote at end\"", true));
|
|
}
|
|
|
|
public void testJoinWithoutColumnPositions() {
|
|
assertEquals("", CsvUtils.join());
|
|
assertEquals("", CsvUtils.join(""));
|
|
assertEquals(",", CsvUtils.join("", ""));
|
|
|
|
assertEquals("text, text,text ",
|
|
CsvUtils.join("text", " text", "text "));
|
|
assertEquals("\"\"\"\",\"\"\"\"\"\",\"\"\"text\"\"\"",
|
|
CsvUtils.join("\"", "\"\"", "\"text\""));
|
|
assertEquals("a b,\"c,d\",\"e\"\"f\"",
|
|
CsvUtils.join("a b", "c,d", "e\"f"));
|
|
}
|
|
|
|
public void testJoinWithoutColumnPositionsWithExtraSpace() {
|
|
final int extraSpace = CsvUtils.JOIN_FLAGS_EXTRA_SPACE;
|
|
assertEquals("", CsvUtils.join(extraSpace));
|
|
assertEquals("", CsvUtils.join(extraSpace, ""));
|
|
assertEquals(", ", CsvUtils.join(extraSpace, "", ""));
|
|
|
|
assertEquals("text, text, text ",
|
|
CsvUtils.join(extraSpace, "text", " text", "text "));
|
|
// ","","text" -> """","""""","""text"""
|
|
assertEquals("\"\"\"\", \"\"\"\"\"\", \"\"\"text\"\"\"",
|
|
CsvUtils.join(extraSpace, "\"", "\"\"", "\"text\""));
|
|
assertEquals("a b, \"c,d\", \"e\"\"f\"",
|
|
CsvUtils.join(extraSpace, "a b", "c,d", "e\"f"));
|
|
}
|
|
|
|
public void testJoinWithoutColumnPositionsWithExtraSpaceAndAlwaysQuoted() {
|
|
final int extrSpaceAndQuoted =
|
|
CsvUtils.JOIN_FLAGS_EXTRA_SPACE | CsvUtils.JOIN_FLAGS_ALWAYS_QUOTED;
|
|
assertEquals("", CsvUtils.join(extrSpaceAndQuoted));
|
|
assertEquals("\"\"", CsvUtils.join(extrSpaceAndQuoted, ""));
|
|
assertEquals("\"\", \"\"", CsvUtils.join(extrSpaceAndQuoted, "", ""));
|
|
|
|
assertEquals("\"text\", \" text\", \"text \"",
|
|
CsvUtils.join(extrSpaceAndQuoted, "text", " text", "text "));
|
|
// ","","text" -> """", """""", """text"""
|
|
assertEquals("\"\"\"\", \"\"\"\"\"\", \"\"\"text\"\"\"",
|
|
CsvUtils.join(extrSpaceAndQuoted, "\"", "\"\"", "\"text\""));
|
|
assertEquals("\"a b\", \"c,d\", \"e\"\"f\"",
|
|
CsvUtils.join(extrSpaceAndQuoted, "a b", "c,d", "e\"f"));
|
|
}
|
|
|
|
public void testJoinWithColumnPositions() {
|
|
final int noFlags = CsvUtils.JOIN_FLAGS_NONE;
|
|
assertEquals("", CsvUtils.join(noFlags, new int[]{}));
|
|
assertEquals(" ", CsvUtils.join(noFlags, new int[]{3}, ""));
|
|
assertEquals(" ,", CsvUtils.join(noFlags, new int[]{1}, "", ""));
|
|
assertEquals(", ", CsvUtils.join(noFlags, new int[]{0, 3}, "", ""));
|
|
|
|
assertEquals("text, text, text ",
|
|
CsvUtils.join(noFlags, new int[]{0, 8, 15}, "text", " text", "text "));
|
|
// ","","text" -> """", """""","""text"""
|
|
assertEquals("\"\"\"\", \"\"\"\"\"\",\"\"\"text\"\"\"",
|
|
CsvUtils.join(noFlags, new int[]{0, 8, 15}, "\"", "\"\"", "\"text\""));
|
|
assertEquals("a b, \"c,d\", \"e\"\"f\"",
|
|
CsvUtils.join(noFlags, new int[]{0, 8, 15}, "a b", "c,d", "e\"f"));
|
|
}
|
|
|
|
public void testJoinWithColumnPositionsWithExtraSpace() {
|
|
final int extraSpace = CsvUtils.JOIN_FLAGS_EXTRA_SPACE;
|
|
assertEquals("", CsvUtils.join(extraSpace, new int[]{}));
|
|
assertEquals(" ", CsvUtils.join(extraSpace, new int[]{3}, ""));
|
|
assertEquals(" , ", CsvUtils.join(extraSpace, new int[]{1}, "", ""));
|
|
assertEquals(", ", CsvUtils.join(extraSpace, new int[]{0, 3}, "", ""));
|
|
|
|
assertEquals("text, text, text ",
|
|
CsvUtils.join(extraSpace, new int[]{0, 8, 15}, "text", " text", "text "));
|
|
// ","","text" -> """", """""", """text"""
|
|
assertEquals("\"\"\"\", \"\"\"\"\"\", \"\"\"text\"\"\"",
|
|
CsvUtils.join(extraSpace, new int[]{0, 8, 15}, "\"", "\"\"", "\"text\""));
|
|
assertEquals("a b, \"c,d\", \"e\"\"f\"",
|
|
CsvUtils.join(extraSpace, new int[]{0, 8, 15}, "a b", "c,d", "e\"f"));
|
|
}
|
|
}
|