diff options
Diffstat (limited to 'tests/src')
12 files changed, 995 insertions, 178 deletions
diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserCsvTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserSplitTests.java index 9014e7cc8..eea1efc49 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserCsvTests.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserSplitTests.java @@ -17,11 +17,13 @@ package com.android.inputmethod.keyboard.internal; import android.app.Instrumentation; +import android.content.Context; +import android.content.res.Resources; import android.test.InstrumentationTestCase; import android.test.suitebuilder.annotation.MediumTest; import com.android.inputmethod.latin.CollectionUtils; -import com.android.inputmethod.latin.StringUtils; +import com.android.inputmethod.latin.LocaleUtils.RunInLocale; import java.lang.reflect.Field; import java.util.ArrayList; @@ -29,16 +31,24 @@ import java.util.Arrays; import java.util.Locale; @MediumTest -public class KeySpecParserCsvTests extends InstrumentationTestCase { - private final KeyboardTextsSet mTextsSet = new KeyboardTextsSet(); +public class KeySpecParserSplitTests extends InstrumentationTestCase { + private static final Locale TEST_LOCALE = Locale.ENGLISH; + final KeyboardTextsSet mTextsSet = new KeyboardTextsSet(); @Override protected void setUp() throws Exception { super.setUp(); final Instrumentation instrumentation = getInstrumentation(); - mTextsSet.setLanguage(Locale.ENGLISH.getLanguage()); - mTextsSet.loadStringResources(instrumentation.getTargetContext()); + final Context targetContext = instrumentation.getTargetContext(); + mTextsSet.setLanguage(TEST_LOCALE.getLanguage()); + new RunInLocale<Void>() { + @Override + protected Void job(final Resources res) { + mTextsSet.loadStringResources(targetContext); + return null; + } + }.runInLocale(targetContext.getResources(), TEST_LOCALE); final String[] testResourceNames = getAllResourceIdNames( com.android.inputmethod.latin.tests.R.string.class); mTextsSet.loadStringResourcesInternal(instrumentation.getContext(), @@ -56,8 +66,8 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { return names.toArray(new String[names.size()]); } - private static void assertArrayEquals(final String message, final Object[] expected, - final Object[] actual) { + private static <T> void assertArrayEquals(final String message, final T[] expected, + final T[] actual) { if (expected == actual) { return; } @@ -70,15 +80,19 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { return; } for (int i = 0; i < expected.length; i++) { - assertEquals(message + " [" + i + "]", - Arrays.toString(expected), Arrays.toString(actual)); + final T e = expected[i]; + final T a = actual[i]; + if (e == a) { + continue; + } + assertEquals(message + " [" + i + "]", e, a); } } private void assertTextArray(final String message, final String value, final String ... expectedArray) { final String resolvedActual = KeySpecParser.resolveTextReference(value, mTextsSet); - final String[] actual = StringUtils.parseCsvString(resolvedActual); + final String[] actual = KeySpecParser.splitKeySpecs(resolvedActual); final String[] expected = (expectedArray.length == 0) ? null : expectedArray; assertArrayEquals(message, expected, actual); } @@ -101,7 +115,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { private static final String SURROGATE1 = PAIR1 + PAIR2; private static final String SURROGATE2 = PAIR1 + PAIR2 + PAIR3; - public void testParseCsvTextZero() { + public void testSplitZero() { assertTextArray("Empty string", ""); assertTextArray("Empty entry", ","); assertTextArray("Empty entry at beginning", ",a", "a"); @@ -110,7 +124,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { assertTextArray("Empty entries with escape", ",a,b\\,c,,d,", "a", "b\\,c", "d"); } - public void testParseCsvTextSingle() { + public void testSplitSingle() { assertTextArray("Single char", "a", "a"); assertTextArray("Surrogate pair", PAIR1, PAIR1); assertTextArray("Single escape", "\\", "\\"); @@ -139,7 +153,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { assertTextArray("Incomplete resource reference 4", "!" + SURROGATE2, "!" + SURROGATE2); } - public void testParseCsvTextSingleEscaped() { + public void testSplitSingleEscaped() { assertTextArray("Escaped char", "\\a", "\\a"); assertTextArray("Escaped surrogate pair", "\\" + PAIR1, "\\" + PAIR1); assertTextArray("Escaped comma", "\\,", "\\,"); @@ -174,7 +188,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { assertTextArray("Escaped !TEXT/NAME", "\\!TEXT/EMPTY_STRING", "\\!TEXT/EMPTY_STRING"); } - public void testParseCsvTextMulti() { + public void testSplitMulti() { assertTextArray("Multiple chars", "a,b,c", "a", "b", "c"); assertTextArray("Multiple chars", "a,b,\\c", "a", "b", "\\c"); assertTextArray("Multiple chars and escape at beginning and end", @@ -189,7 +203,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { " abc ", " def ", " ghi "); } - public void testParseCsvTextMultiEscaped() { + public void testSplitMultiEscaped() { assertTextArray("Multiple chars with comma", "a,\\,,c", "a", "\\,", "c"); assertTextArray("Multiple chars with comma surrounded by spaces", " a , \\, , c ", " a ", " \\, ", " c "); @@ -208,17 +222,17 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "\\!", "\\!TEXT/EMPTY_STRING"); } - public void testParseCsvResourceError() { + public void testSplitResourceError() { assertError("Incomplete resource name", "!text/", "!text/"); assertError("Non existing resource", "!text/non_existing"); } - public void testParseCsvResourceZero() { + public void testSplitResourceZero() { assertTextArray("Empty string", "!text/empty_string"); } - public void testParseCsvResourceSingle() { + public void testSplitResourceSingle() { assertTextArray("Single char", "!text/single_char", "a"); assertTextArray("Space", @@ -240,7 +254,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "\\\\!text/single_char", "\\\\a"); } - public void testParseCsvResourceSingleEscaped() { + public void testSplitResourceSingleEscaped() { assertTextArray("Escaped char", "!text/escaped_char", "\\a"); assertTextArray("Escaped comma", @@ -267,7 +281,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "!text/escaped_label_with_escape", "a\\\\c"); } - public void testParseCsvResourceMulti() { + public void testSplitResourceMulti() { assertTextArray("Multiple chars", "!text/multiple_chars", "a", "b", "c"); assertTextArray("Multiple chars surrounded by spaces", @@ -279,7 +293,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "!text/multiple_labels_surrounded_by_spaces", " abc ", " def ", " ghi "); } - public void testParseCsvResourcetMultiEscaped() { + public void testSplitResourcetMultiEscaped() { assertTextArray("Multiple chars with comma", "!text/multiple_chars_with_comma", "a", "\\,", "c"); @@ -300,7 +314,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { " ab\\\\ ", " d\\\\\\, ", " g\\,i "); } - public void testParseMultipleResources() { + public void testSplitMultipleResources() { assertTextArray("Literals and resources", "1,!text/multiple_chars,z", "1", "a", "b", "c", "z"); assertTextArray("Literals and resources and escape at end", @@ -322,7 +336,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "abcabc", "def", "ghi"); } - public void testParseIndirectReference() { + public void testSplitIndirectReference() { assertTextArray("Indirect", "!text/indirect_string", "a", "b", "c"); assertTextArray("Indirect with literal", @@ -331,7 +345,7 @@ public class KeySpecParserCsvTests extends InstrumentationTestCase { "!text/indirect2_string", "a", "b", "c"); } - public void testParseInfiniteIndirectReference() { + public void testSplitInfiniteIndirectReference() { assertError("Infinite indirection", "1,!text/infinite_indirection,2", "1", "infinite", "<infinite>", "loop", "2"); } diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java index b1ae6f5b7..b55158d3e 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeySpecParserTests.java @@ -20,23 +20,27 @@ import static com.android.inputmethod.keyboard.internal.KeyboardIconsSet.ICON_UN import static com.android.inputmethod.latin.Constants.CODE_OUTPUT_TEXT; import static com.android.inputmethod.latin.Constants.CODE_UNSPECIFIED; +import android.content.Context; +import android.content.res.Resources; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.SmallTest; import com.android.inputmethod.latin.Constants; +import com.android.inputmethod.latin.LocaleUtils.RunInLocale; import java.util.Arrays; import java.util.Locale; @SmallTest public class KeySpecParserTests extends AndroidTestCase { - private final KeyboardCodesSet mCodesSet = new KeyboardCodesSet(); - private final KeyboardTextsSet mTextsSet = new KeyboardTextsSet(); + private final static Locale TEST_LOCALE = Locale.ENGLISH; + final KeyboardCodesSet mCodesSet = new KeyboardCodesSet(); + final KeyboardTextsSet mTextsSet = new KeyboardTextsSet(); private static final String CODE_SETTINGS = "!code/key_settings"; private static final String ICON_SETTINGS = "!icon/settings_key"; - private static final String CODE_SETTINGS_UPPERCASE = CODE_SETTINGS.toUpperCase(); - private static final String ICON_SETTINGS_UPPERCASE = ICON_SETTINGS.toUpperCase(); + private static final String CODE_SETTINGS_UPPERCASE = CODE_SETTINGS.toUpperCase(Locale.ROOT); + private static final String ICON_SETTINGS_UPPERCASE = ICON_SETTINGS.toUpperCase(Locale.ROOT); private static final String CODE_NON_EXISTING = "!code/non_existing"; private static final String ICON_NON_EXISTING = "!icon/non_existing"; @@ -48,10 +52,17 @@ public class KeySpecParserTests extends AndroidTestCase { protected void setUp() throws Exception { super.setUp(); - final String language = Locale.ENGLISH.getLanguage(); + final String language = TEST_LOCALE.getLanguage(); mCodesSet.setLanguage(language); mTextsSet.setLanguage(language); - mTextsSet.loadStringResources(getContext()); + final Context context = getContext(); + new RunInLocale<Void>() { + @Override + protected Void job(final Resources res) { + mTextsSet.loadStringResources(context); + return null; + } + }.runInLocale(context.getResources(), TEST_LOCALE); mCodeSettings = KeySpecParser.parseCode( CODE_SETTINGS, mCodesSet, CODE_UNSPECIFIED); @@ -587,7 +598,7 @@ public class KeySpecParserTests extends AndroidTestCase { new String[] { null, "a", "b", "c" }, true); // Upper case specification will not work. assertGetBooleanValue("HAS LABEL", HAS_LABEL, - new String[] { HAS_LABEL.toUpperCase(), "a", "b", "c" }, + new String[] { HAS_LABEL.toUpperCase(Locale.ROOT), "a", "b", "c" }, new String[] { "!HASLABEL!", "a", "b", "c" }, false); assertGetBooleanValue("No has label", HAS_LABEL, @@ -600,13 +611,13 @@ public class KeySpecParserTests extends AndroidTestCase { // Upper case specification will not work. assertGetBooleanValue("Multiple has label", HAS_LABEL, new String[] { - "a", HAS_LABEL.toUpperCase(), "b", "c", HAS_LABEL, "d" }, + "a", HAS_LABEL.toUpperCase(Locale.ROOT), "b", "c", HAS_LABEL, "d" }, new String[] { "a", "!HASLABEL!", "b", "c", null, "d" }, true); // Upper case specification will not work. assertGetBooleanValue("Multiple has label with needs dividers", HAS_LABEL, new String[] { - "a", HAS_LABEL, "b", NEEDS_DIVIDER, HAS_LABEL.toUpperCase(), "d" }, + "a", HAS_LABEL, "b", NEEDS_DIVIDER, HAS_LABEL.toUpperCase(Locale.ROOT), "d" }, new String[] { "a", null, "b", NEEDS_DIVIDER, "!HASLABEL!", "d" }, true); } @@ -625,7 +636,7 @@ public class KeySpecParserTests extends AndroidTestCase { new String[] { null, "a", "b", "c" }, 3); // Upper case specification will not work. assertGetIntValue("FIXED COLUMN ORDER 3", FIXED_COLUMN_ORDER, -1, - new String[] { FIXED_COLUMN_ORDER.toUpperCase() + "3", "a", "b", "c" }, + new String[] { FIXED_COLUMN_ORDER.toUpperCase(Locale.ROOT) + "3", "a", "b", "c" }, new String[] { "!FIXEDCOLUMNORDER!3", "a", "b", "c" }, -1); assertGetIntValue("No fixed column order", FIXED_COLUMN_ORDER, -1, @@ -641,7 +652,7 @@ public class KeySpecParserTests extends AndroidTestCase { // Upper case specification will not work. assertGetIntValue("Multiple fixed column order 5,3 with has label", FIXED_COLUMN_ORDER, -1, new String[] { - FIXED_COLUMN_ORDER.toUpperCase() + "5", HAS_LABEL, "a", + FIXED_COLUMN_ORDER.toUpperCase(Locale.ROOT) + "5", HAS_LABEL, "a", FIXED_COLUMN_ORDER + "3", "b" }, new String[] { "!FIXEDCOLUMNORDER!5", HAS_LABEL, "a", null, "b" }, 3); } diff --git a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java index e06ca064a..6991d05fa 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/KeyboardStateTestsBase.java @@ -18,6 +18,8 @@ package com.android.inputmethod.keyboard.internal; import android.test.AndroidTestCase; +import com.android.inputmethod.latin.Constants; + public class KeyboardStateTestsBase extends AndroidTestCase implements MockKeyboardSwitcher.MockConstants { protected MockKeyboardSwitcher mSwitcher; @@ -119,7 +121,11 @@ public class KeyboardStateTestsBase extends AndroidTestCase public void longPressKey(final int code, final int afterPress, final int afterLongPress) { pressKey(code, afterPress); - mSwitcher.onLongPressTimeout(code); + // Long press shift key will register {@link Constants#CODE_CAPS_LOCK}. See + // {@link R.xml#key_styles_common} and its baseForShiftKeyStyle. We thus emulate the + // behavior here. + final int longPressCode = code == CODE_SHIFT ? Constants.CODE_CAPSLOCK : code; + mSwitcher.onCodeInput(longPressCode); assertLayout("afterLongPress", afterLongPress, mSwitcher.getLayoutId()); } diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java b/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java new file mode 100644 index 000000000..e2a11ab99 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/MatrixUtilsTests.java @@ -0,0 +1,84 @@ +/* + * 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.keyboard.internal; + +import com.android.inputmethod.keyboard.internal.MatrixUtils.MatrixOperationFailedException; + +import android.test.AndroidTestCase; +import android.test.suitebuilder.annotation.SmallTest; + +@SmallTest +public class MatrixUtilsTests extends AndroidTestCase { + // "run tests" -c com.android.inputmethod.keyboard.internal.MatrixUtilsTests + private static final boolean DEBUG = false; + private static final float EPSILON = 0.00001f; + + private static void assertEqualsFloat(float f0, float f1) { + assertEqualsFloat(f0, f1, EPSILON); + } + + /* package */ static void assertEqualsFloat(float f0, float f1, float error) { + assertTrue(Math.abs(f0 - f1) < error); + } + + public void testMulti() { + final float[][] matrixA = {{1, 2}, {3, 4}}; + final float[][] matrixB = {{5, 6}, {7, 8}}; + final float[][] retval = new float[2][2]; + try { + MatrixUtils.multiply(matrixA, matrixB, retval); + } catch (MatrixOperationFailedException e) { + assertTrue(false); + } + if (DEBUG) { + MatrixUtils.dump("multi", retval); + } + assertEqualsFloat(retval[0][0], 19); + assertEqualsFloat(retval[0][1], 22); + assertEqualsFloat(retval[1][0], 43); + assertEqualsFloat(retval[1][1], 50); + } + + public void testInverse() { + final int N = 4; + final float[][] matrix = + {{1, 2, 3, 4}, {4, 0, 5, 6}, {6, 4, 2, 0}, {6, 4, 2, 1}}; + final float[][] inverse = new float[N][N]; + final float[][] tempMatrix = new float[N][N]; + for (int i = 0; i < N; ++i) { + for (int j = 0; j < N; ++j) { + tempMatrix[i][j] = matrix[i][j]; + } + } + final float[][] retval = new float[N][N]; + try { + MatrixUtils.inverse(tempMatrix, inverse); + } catch (MatrixOperationFailedException e) { + assertTrue(false); + } + try { + MatrixUtils.multiply(matrix, inverse, retval); + } catch (MatrixOperationFailedException e) { + assertTrue(false); + } + for (int i = 0; i < N; ++i) { + for (int j = 0; j < N; ++j) { + assertEqualsFloat(((i == j) ? 1.0f : 0.0f), retval[i][j]); + } + } + } +} diff --git a/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java b/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java index 2544b6c52..8506e16f2 100644 --- a/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java +++ b/tests/src/com/android/inputmethod/keyboard/internal/MockKeyboardSwitcher.java @@ -53,7 +53,7 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { // Following InputConnection's behavior. Simulating InputType.TYPE_TEXT_FLAG_CAP_WORDS. private int mAutoCapsState = MockConstants.CAP_MODE_OFF; - private boolean mIsInDoubleTapTimeout; + private boolean mIsInDoubleTapShiftKeyTimeout; private int mLongPressTimeoutCode; private final KeyboardState mState = new KeyboardState(this); @@ -81,7 +81,7 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { } public void expireDoubleTapTimeout() { - mIsInDoubleTapTimeout = false; + mIsInDoubleTapShiftKeyTimeout = false; } @Override @@ -125,41 +125,18 @@ public class MockKeyboardSwitcher implements KeyboardState.SwitchActions { } @Override - public void startDoubleTapTimer() { - mIsInDoubleTapTimeout = true; + public void startDoubleTapShiftKeyTimer() { + mIsInDoubleTapShiftKeyTimeout = true; } @Override - public void cancelDoubleTapTimer() { - mIsInDoubleTapTimeout = false; + public void cancelDoubleTapShiftKeyTimer() { + mIsInDoubleTapShiftKeyTimeout = false; } @Override - public boolean isInDoubleTapTimeout() { - return mIsInDoubleTapTimeout; - } - - @Override - public void startLongPressTimer(final int code) { - mLongPressTimeoutCode = code; - } - - @Override - public void cancelLongPressTimer() { - mLongPressTimeoutCode = 0; - } - - @Override - public void hapticAndAudioFeedback(final int code) { - // Nothing to do. - } - - public void onLongPressTimeout(final int code) { - // TODO: Handle simultaneous long presses. - if (mLongPressTimeoutCode == code) { - mLongPressTimeoutCode = 0; - mState.onLongPressTimeout(code); - } + public boolean isInDoubleTapShiftKeyTimeout() { + return mIsInDoubleTapShiftKeyTimeout; } public void updateShiftState() { diff --git a/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java b/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java new file mode 100644 index 000000000..293741af2 --- /dev/null +++ b/tests/src/com/android/inputmethod/keyboard/internal/SmoothingUtilsTests.java @@ -0,0 +1,45 @@ +/* + * 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.keyboard.internal; + +import com.android.inputmethod.keyboard.internal.MatrixUtils.MatrixOperationFailedException; + +import android.test.AndroidTestCase; +import android.test.suitebuilder.annotation.SmallTest; + +@SmallTest +public class SmoothingUtilsTests extends AndroidTestCase { + // "run tests" -c com.android.inputmethod.keyboard.internal.SmoothingUtilsTests + private static final boolean DEBUG = false; + + public void testGet3DParamaters() { + final float[] xs = new float[] {0, 1, 2, 3, 4}; + final float[] ys = new float[] {1, 4, 15, 40, 85}; // y = x^3 + x^2 + x + 1 + final float[][] retval = new float[4][1]; + try { + SmoothingUtils.get3DParameters(xs, ys, retval); + if (DEBUG) { + MatrixUtils.dump("3d", retval); + } + for (int i = 0; i < 4; ++i) { + MatrixUtilsTests.assertEqualsFloat(retval[i][0], 1.0f, 0.001f); + } + } catch (MatrixOperationFailedException e) { + assertTrue(false); + } + } +} diff --git a/tests/src/com/android/inputmethod/latin/InputPointersTests.java b/tests/src/com/android/inputmethod/latin/InputPointersTests.java index e1149b3fd..301582979 100644 --- a/tests/src/com/android/inputmethod/latin/InputPointersTests.java +++ b/tests/src/com/android/inputmethod/latin/InputPointersTests.java @@ -108,13 +108,13 @@ public class InputPointersTests extends AndroidTestCase { assertNotSame("pointerIds after copy", dst.getPointerIds(), src.getPointerIds()); assertNotSame("times after copy", dst.getTimes(), src.getTimes()); final int size = dst.getPointerSize(); - assertArrayEquals("xCoordinates values after copy", + assertIntArrayEquals("xCoordinates values after copy", dst.getXCoordinates(), 0, src.getXCoordinates(), 0, size); - assertArrayEquals("yCoordinates values after copy", + assertIntArrayEquals("yCoordinates values after copy", dst.getYCoordinates(), 0, src.getYCoordinates(), 0, size); - assertArrayEquals("pointerIds values after copy", + assertIntArrayEquals("pointerIds values after copy", dst.getPointerIds(), 0, src.getPointerIds(), 0, size); - assertArrayEquals("times values after copy", + assertIntArrayEquals("times values after copy", dst.getTimes(), 0, src.getTimes(), 0, size); } @@ -135,34 +135,34 @@ public class InputPointersTests extends AndroidTestCase { dst.append(src, 0, 0); assertEquals("size after append zero", dstLen, dst.getPointerSize()); - assertArrayEquals("xCoordinates after append zero", + assertIntArrayEquals("xCoordinates after append zero", dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen); - assertArrayEquals("yCoordinates after append zero", + assertIntArrayEquals("yCoordinates after append zero", dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen); - assertArrayEquals("pointerIds after append zero", + assertIntArrayEquals("pointerIds after append zero", dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen); - assertArrayEquals("times after append zero", + assertIntArrayEquals("times after append zero", dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen); dst.append(src, 0, srcLen); assertEquals("size after append", dstLen + srcLen, dst.getPointerSize()); assertTrue("primitive length after append", dst.getPointerIds().length >= dstLen + srcLen); - assertArrayEquals("original xCoordinates values after append", + assertIntArrayEquals("original xCoordinates values after append", dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen); - assertArrayEquals("original yCoordinates values after append", + assertIntArrayEquals("original yCoordinates values after append", dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen); - assertArrayEquals("original pointerIds values after append", + assertIntArrayEquals("original pointerIds values after append", dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen); - assertArrayEquals("original times values after append", + assertIntArrayEquals("original times values after append", dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen); - assertArrayEquals("appended xCoordinates values after append", + assertIntArrayEquals("appended xCoordinates values after append", src.getXCoordinates(), 0, dst.getXCoordinates(), dstLen, srcLen); - assertArrayEquals("appended yCoordinates values after append", + assertIntArrayEquals("appended yCoordinates values after append", src.getYCoordinates(), 0, dst.getYCoordinates(), dstLen, srcLen); - assertArrayEquals("appended pointerIds values after append", + assertIntArrayEquals("appended pointerIds values after append", src.getPointerIds(), 0, dst.getPointerIds(), dstLen, srcLen); - assertArrayEquals("appended times values after append", + assertIntArrayEquals("appended times values after append", src.getTimes(), 0, dst.getTimes(), dstLen, srcLen); } @@ -190,47 +190,55 @@ public class InputPointersTests extends AndroidTestCase { dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, 0); assertEquals("size after append zero", dstLen, dst.getPointerSize()); - assertArrayEquals("xCoordinates after append zero", + assertIntArrayEquals("xCoordinates after append zero", dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen); - assertArrayEquals("yCoordinates after append zero", + assertIntArrayEquals("yCoordinates after append zero", dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen); - assertArrayEquals("pointerIds after append zero", + assertIntArrayEquals("pointerIds after append zero", dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen); - assertArrayEquals("times after append zero", + assertIntArrayEquals("times after append zero", dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen); dst.append(srcPointerId, srcTimes, srcXCoords, srcYCoords, 0, srcLen); assertEquals("size after append", dstLen + srcLen, dst.getPointerSize()); assertTrue("primitive length after append", dst.getPointerIds().length >= dstLen + srcLen); - assertArrayEquals("original xCoordinates values after append", + assertIntArrayEquals("original xCoordinates values after append", dstCopy.getXCoordinates(), 0, dst.getXCoordinates(), 0, dstLen); - assertArrayEquals("original yCoordinates values after append", + assertIntArrayEquals("original yCoordinates values after append", dstCopy.getYCoordinates(), 0, dst.getYCoordinates(), 0, dstLen); - assertArrayEquals("original pointerIds values after append", + assertIntArrayEquals("original pointerIds values after append", dstCopy.getPointerIds(), 0, dst.getPointerIds(), 0, dstLen); - assertArrayEquals("original times values after append", + assertIntArrayEquals("original times values after append", dstCopy.getTimes(), 0, dst.getTimes(), 0, dstLen); - assertArrayEquals("appended xCoordinates values after append", + assertIntArrayEquals("appended xCoordinates values after append", srcXCoords.getPrimitiveArray(), 0, dst.getXCoordinates(), dstLen, srcLen); - assertArrayEquals("appended yCoordinates values after append", + assertIntArrayEquals("appended yCoordinates values after append", srcYCoords.getPrimitiveArray(), 0, dst.getYCoordinates(), dstLen, srcLen); - assertArrayEquals("appended pointerIds values after append", + assertIntArrayEquals("appended pointerIds values after append", srcPointerIds, 0, dst.getPointerIds(), dstLen, srcLen); - assertArrayEquals("appended times values after append", + assertIntArrayEquals("appended times values after append", srcTimes.getPrimitiveArray(), 0, dst.getTimes(), dstLen, srcLen); } - private static void assertArrayEquals(String message, int[] expecteds, int expectedPos, - int[] actuals, int actualPos, int length) { - if (expecteds == null && actuals == null) { + // TODO: Consolidate this method with + // {@link ResizableIntArrayTests#assertIntArrayEquals(String,int[],int,int[],int,int)}. + private static void assertIntArrayEquals(final String message, final int[] expecteds, + final int expectedPos, final int[] actuals, final int actualPos, final int length) { + if (expecteds == actuals) { return; } if (expecteds == null || actuals == null) { - fail(message + ": expecteds=" + expecteds + " actuals=" + actuals); + assertEquals(message, Arrays.toString(expecteds), Arrays.toString(actuals)); + return; + } + if (expecteds.length < expectedPos + length || actuals.length < actualPos + length) { + fail(message + ": insufficient length: expecteds=" + Arrays.toString(expecteds) + + " actuals=" + Arrays.toString(actuals)); + return; } for (int i = 0; i < length; i++) { - assertEquals(message + ": element at " + i, + assertEquals(message + " [" + i + "]", expecteds[i + expectedPos], actuals[i + actualPos]); } } diff --git a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java index 2d1b836c2..b9fee950e 100644 --- a/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java +++ b/tests/src/com/android/inputmethod/latin/ResizableIntArrayTests.java @@ -19,6 +19,8 @@ package com.android.inputmethod.latin; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.SmallTest; +import java.util.Arrays; + @SmallTest public class ResizableIntArrayTests extends AndroidTestCase { private static final int DEFAULT_CAPACITY = 48; @@ -186,7 +188,7 @@ public class ResizableIntArrayTests extends AndroidTestCase { assertEquals("length after copy", dst.getLength(), src.getLength()); assertSame("array after copy", array, dst.getPrimitiveArray()); assertNotSame("array after copy", dst.getPrimitiveArray(), src.getPrimitiveArray()); - assertArrayEquals("values after copy", + assertIntArrayEquals("values after copy", dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength()); final int smallerLength = DEFAULT_CAPACITY / 2; @@ -197,7 +199,7 @@ public class ResizableIntArrayTests extends AndroidTestCase { assertEquals("length after copy to smaller", dst.getLength(), src.getLength()); assertNotSame("array after copy to smaller", array2, array3); assertNotSame("array after copy to smaller", array3, src.getPrimitiveArray()); - assertArrayEquals("values after copy to smaller", + assertIntArrayEquals("values after copy to smaller", dst.getPrimitiveArray(), 0, src.getPrimitiveArray(), 0, dst.getLength()); } @@ -220,7 +222,7 @@ public class ResizableIntArrayTests extends AndroidTestCase { dst.append(src, 0, 0); assertEquals("length after append zero", dstLen, dst.getLength()); assertSame("array after append zero", array, dst.getPrimitiveArray()); - assertArrayEquals("values after append zero", + assertIntArrayEquals("values after append zero", dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen); dst.append(src, 0, srcLen); @@ -228,9 +230,9 @@ public class ResizableIntArrayTests extends AndroidTestCase { assertSame("array after append", array, dst.getPrimitiveArray()); assertTrue("primitive length after append", dst.getPrimitiveArray().length >= dstLen + srcLen); - assertArrayEquals("original values after append", + assertIntArrayEquals("original values after append", dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen); - assertArrayEquals("appended values after append", + assertIntArrayEquals("appended values after append", src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen); dst.append(src, 0, srcLen); @@ -238,11 +240,11 @@ public class ResizableIntArrayTests extends AndroidTestCase { assertNotSame("array after 2nd append", array, dst.getPrimitiveArray()); assertTrue("primitive length after 2nd append", dst.getPrimitiveArray().length >= dstLen + srcLen * 2); - assertArrayEquals("original values after 2nd append", + assertIntArrayEquals("original values after 2nd append", dstCopy.getPrimitiveArray(), 0, dst.getPrimitiveArray(), 0, dstLen); - assertArrayEquals("appended values after 2nd append", + assertIntArrayEquals("appended values after 2nd append", src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen, srcLen); - assertArrayEquals("appended values after 2nd append", + assertIntArrayEquals("appended values after 2nd append", src.getPrimitiveArray(), 0, dst.getPrimitiveArray(), dstLen + srcLen, srcLen); } @@ -319,16 +321,22 @@ public class ResizableIntArrayTests extends AndroidTestCase { } } - private static void assertArrayEquals(String message, int[] expecteds, int expectedPos, - int[] actuals, int actualPos, int length) { - if (expecteds == null && actuals == null) { + private static void assertIntArrayEquals(final String message, final int[] expecteds, + final int expectedPos, final int[] actuals, final int actualPos, final int length) { + if (expecteds == actuals) { return; } if (expecteds == null || actuals == null) { - fail(message + ": expecteds=" + expecteds + " actuals=" + actuals); + assertEquals(message, Arrays.toString(expecteds), Arrays.toString(actuals)); + return; + } + if (expecteds.length < expectedPos + length || actuals.length < actualPos + length) { + fail(message + ": insufficient length: expecteds=" + Arrays.toString(expecteds) + + " actuals=" + Arrays.toString(actuals)); + return; } for (int i = 0; i < length; i++) { - assertEquals(message + ": element at " + i, + assertEquals(message + " [" + i + "]", expecteds[i + expectedPos], actuals[i + actualPos]); } } diff --git a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java index ed16846b9..c915522ee 100644 --- a/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java +++ b/tests/src/com/android/inputmethod/latin/ResourceUtilsTests.java @@ -19,25 +19,41 @@ package com.android.inputmethod.latin; import android.test.AndroidTestCase; import android.test.suitebuilder.annotation.SmallTest; +import com.android.inputmethod.latin.ResourceUtils.DeviceOverridePatternSyntaxError; + import java.util.HashMap; @SmallTest public class ResourceUtilsTests extends AndroidTestCase { public void testFindDefaultConstant() { final String[] nullArray = null; - assertNull(ResourceUtils.findDefaultConstant(nullArray)); - final String[] emptyArray = {}; - assertNull(ResourceUtils.findDefaultConstant(emptyArray)); - final String[] array = { + "HARDWARE=grouper,0.3", + "HARDWARE=mako,0.4", + ",defaultValue1", + "HARDWARE=manta,0.2", + ",defaultValue2", + }; + + try { + assertNull(ResourceUtils.findDefaultConstant(nullArray)); + assertNull(ResourceUtils.findDefaultConstant(emptyArray)); + assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1"); + } catch (final DeviceOverridePatternSyntaxError e) { + fail(e.getMessage()); + } + + final String[] errorArray = { "HARDWARE=grouper,0.3", - "HARDWARE=mako,0.4", - ",defaultValue1", - "HARDWARE=manta,0.2", - ",defaultValue2", + "no_comma" }; - assertEquals(ResourceUtils.findDefaultConstant(array), "defaultValue1"); + try { + final String defaultValue = ResourceUtils.findDefaultConstant(errorArray); + fail("exception should be thrown: defaultValue=" + defaultValue); + } catch (final DeviceOverridePatternSyntaxError e) { + assertEquals("Array element has no comma: no_comma", e.getMessage()); + } } public void testFindConstantForKeyValuePairsSimple() { @@ -67,33 +83,23 @@ public class ResourceUtilsTests extends AndroidTestCase { final HashMap<String,String> keyValues = CollectionUtils.newHashMap(); keyValues.put(HARDWARE_KEY, "grouper"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3"); + assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "mako"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4"); + assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "manta"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2"); + assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); + + keyValues.clear(); + keyValues.put("hardware", "grouper"); + assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); - try { - keyValues.clear(); - keyValues.put("hardware", "grouper"); - final String constant = ResourceUtils.findConstantForKeyValuePairs(keyValues, array); - fail("condition without HARDWARE must fail: constant=" + constant); - } catch (final RuntimeException e) { - assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper"); - } keyValues.clear(); keyValues.put(HARDWARE_KEY, "MAKO"); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "mantaray"); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); - try { - final String constant = ResourceUtils.findConstantForKeyValuePairs( - emptyKeyValue, array); - fail("emptyCondition shouldn't match: constant=" + constant); - } catch (final RuntimeException e) { - assertEquals(e.getMessage(), "Found unknown key: HARDWARE=grouper"); - } + assertNull(ResourceUtils.findConstantForKeyValuePairs(emptyKeyValue, array)); } public void testFindConstantForKeyValuePairsCombined() { @@ -102,6 +108,8 @@ public class ResourceUtilsTests extends AndroidTestCase { final String MANUFACTURER_KEY = "MANUFACTURER"; final String[] array = { ",defaultValue", + "no_comma", + "error_pattern,0.1", "HARDWARE=grouper:MANUFACTURER=asus,0.3", "HARDWARE=mako:MODEL=Nexus 4,0.4", "HARDWARE=manta:MODEL=Nexus 10:MANUFACTURER=samsung,0.2" @@ -117,25 +125,25 @@ public class ResourceUtilsTests extends AndroidTestCase { keyValues.put(HARDWARE_KEY, "grouper"); keyValues.put(MODEL_KEY, "Nexus 7"); keyValues.put(MANUFACTURER_KEY, "asus"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3"); + assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray)); keyValues.clear(); keyValues.put(HARDWARE_KEY, "mako"); keyValues.put(MODEL_KEY, "Nexus 4"); keyValues.put(MANUFACTURER_KEY, "LGE"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4"); + assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray)); keyValues.clear(); keyValues.put(HARDWARE_KEY, "manta"); keyValues.put(MODEL_KEY, "Nexus 10"); keyValues.put(MANUFACTURER_KEY, "samsung"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2"); + assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray)); keyValues.put(HARDWARE_KEY, "mantaray"); assertNull(ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray), "0.2"); + assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, failArray)); } public void testFindConstantForKeyValuePairsRegexp() { @@ -144,6 +152,8 @@ public class ResourceUtilsTests extends AndroidTestCase { final String MANUFACTURER_KEY = "MANUFACTURER"; final String[] array = { ",defaultValue", + "no_comma", + "HARDWARE=error_regexp:MANUFACTURER=error[regexp,0.1", "HARDWARE=grouper|tilapia:MANUFACTURER=asus,0.3", "HARDWARE=[mM][aA][kK][oO]:MODEL=Nexus 4,0.4", "HARDWARE=manta.*:MODEL=Nexus 10:MANUFACTURER=samsung,0.2" @@ -153,24 +163,24 @@ public class ResourceUtilsTests extends AndroidTestCase { keyValues.put(HARDWARE_KEY, "grouper"); keyValues.put(MODEL_KEY, "Nexus 7"); keyValues.put(MANUFACTURER_KEY, "asus"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3"); + assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "tilapia"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.3"); + assertEquals("0.3", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.clear(); keyValues.put(HARDWARE_KEY, "mako"); keyValues.put(MODEL_KEY, "Nexus 4"); keyValues.put(MANUFACTURER_KEY, "LGE"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4"); + assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "MAKO"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.4"); + assertEquals("0.4", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.clear(); keyValues.put(HARDWARE_KEY, "manta"); keyValues.put(MODEL_KEY, "Nexus 10"); keyValues.put(MANUFACTURER_KEY, "samsung"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2"); + assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); keyValues.put(HARDWARE_KEY, "mantaray"); - assertEquals(ResourceUtils.findConstantForKeyValuePairs(keyValues, array), "0.2"); + assertEquals("0.2", ResourceUtils.findConstantForKeyValuePairs(keyValues, array)); } } diff --git a/tests/src/com/android/inputmethod/latin/StringUtilsTests.java b/tests/src/com/android/inputmethod/latin/StringUtilsTests.java index 29e790a7d..4f260987b 100644 --- a/tests/src/com/android/inputmethod/latin/StringUtilsTests.java +++ b/tests/src/com/android/inputmethod/latin/StringUtilsTests.java @@ -40,57 +40,62 @@ public class StringUtilsTests extends AndroidTestCase { })); } - public void testContainsInCsv() { - assertFalse("null", StringUtils.containsInCsv("key", null)); - assertFalse("empty", StringUtils.containsInCsv("key", "")); - assertFalse("not in 1 element", StringUtils.containsInCsv("key", "key1")); - assertFalse("not in 2 elements", StringUtils.containsInCsv("key", "key1,key2")); - - assertTrue("in 1 element", StringUtils.containsInCsv("key", "key")); - assertTrue("in 2 elements", StringUtils.containsInCsv("key", "key1,key")); + public void testContainsInExtraValues() { + assertFalse("null", StringUtils.containsInCommaSplittableText("key", null)); + assertFalse("empty", StringUtils.containsInCommaSplittableText("key", "")); + assertFalse("not in 1 element", + StringUtils.containsInCommaSplittableText("key", "key1")); + assertFalse("not in 2 elements", + StringUtils.containsInCommaSplittableText("key", "key1,key2")); + + assertTrue("in 1 element", StringUtils.containsInCommaSplittableText("key", "key")); + assertTrue("in 2 elements", StringUtils.containsInCommaSplittableText("key", "key1,key")); } - public void testAppendToCsvIfNotExists() { - assertEquals("null", "key", StringUtils.appendToCsvIfNotExists("key", null)); - assertEquals("empty", "key", StringUtils.appendToCsvIfNotExists("key", "")); + public void testAppendToExtraValuesIfNotExists() { + assertEquals("null", "key", + StringUtils.appendToCommaSplittableTextIfNotExists("key", null)); + assertEquals("empty", "key", + StringUtils.appendToCommaSplittableTextIfNotExists("key", "")); assertEquals("not in 1 element", "key1,key", - StringUtils.appendToCsvIfNotExists("key", "key1")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1")); assertEquals("not in 2 elements", "key1,key2,key", - StringUtils.appendToCsvIfNotExists("key", "key1,key2")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key2")); assertEquals("in 1 element", "key", - StringUtils.appendToCsvIfNotExists("key", "key")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key")); assertEquals("in 2 elements at position 1", "key,key2", - StringUtils.appendToCsvIfNotExists("key", "key,key2")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key,key2")); assertEquals("in 2 elements at position 2", "key1,key", - StringUtils.appendToCsvIfNotExists("key", "key1,key")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key")); assertEquals("in 3 elements at position 2", "key1,key,key3", - StringUtils.appendToCsvIfNotExists("key", "key1,key,key3")); + StringUtils.appendToCommaSplittableTextIfNotExists("key", "key1,key,key3")); } - public void testRemoveFromCsvIfExists() { - assertEquals("null", "", StringUtils.removeFromCsvIfExists("key", null)); - assertEquals("empty", "", StringUtils.removeFromCsvIfExists("key", "")); + public void testRemoveFromExtraValuesIfExists() { + assertEquals("null", "", StringUtils.removeFromCommaSplittableTextIfExists("key", null)); + assertEquals("empty", "", StringUtils.removeFromCommaSplittableTextIfExists("key", "")); assertEquals("not in 1 element", "key1", - StringUtils.removeFromCsvIfExists("key", "key1")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key1")); assertEquals("not in 2 elements", "key1,key2", - StringUtils.removeFromCsvIfExists("key", "key1,key2")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key2")); assertEquals("in 1 element", "", - StringUtils.removeFromCsvIfExists("key", "key")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key")); assertEquals("in 2 elements at position 1", "key2", - StringUtils.removeFromCsvIfExists("key", "key,key2")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key2")); assertEquals("in 2 elements at position 2", "key1", - StringUtils.removeFromCsvIfExists("key", "key1,key")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key")); assertEquals("in 3 elements at position 2", "key1,key3", - StringUtils.removeFromCsvIfExists("key", "key1,key,key3")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key1,key,key3")); assertEquals("in 3 elements at position 1,2,3", "", - StringUtils.removeFromCsvIfExists("key", "key,key,key")); + StringUtils.removeFromCommaSplittableTextIfExists("key", "key,key,key")); assertEquals("in 5 elements at position 2,4", "key1,key3,key5", - StringUtils.removeFromCsvIfExists("key", "key1,key,key3,key,key5")); + StringUtils.removeFromCommaSplittableTextIfExists( + "key", "key1,key,key3,key,key5")); } diff --git a/tests/src/com/android/inputmethod/latin/utils/Base64ReaderTests.java b/tests/src/com/android/inputmethod/latin/utils/Base64ReaderTests.java new file mode 100644 index 000000000..b311f5d37 --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/utils/Base64ReaderTests.java @@ -0,0 +1,225 @@ +/* + * 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 java.io.EOFException; +import java.io.IOException; +import java.io.LineNumberReader; +import java.io.StringReader; + +@SmallTest +public class Base64ReaderTests extends AndroidTestCase { + private static final String EMPTY_STRING = ""; + private static final String INCOMPLETE_CHAR1 = "Q"; + // Encode 'A'. + private static final String INCOMPLETE_CHAR2 = "QQ"; + // Encode 'A', 'B' + private static final String INCOMPLETE_CHAR3 = "QUI"; + // Encode 'A', 'B', 'C' + private static final String COMPLETE_CHAR4 = "QUJD"; + private static final String ALL_BYTE_PATTERN = + "AAECAwQFBgcICQoLDA0ODxAREhMUFRYXGBkaGxwdHh8gISIj\n" + + "JCUmJygpKissLS4vMDEyMzQ1Njc4OTo7PD0+P0BBQkNERUZH\n" + + "SElKS0xNTk9QUVJTVFVWV1hZWltcXV5fYGFiY2RlZmdoaWpr\n" + + "bG1ub3BxcnN0dXZ3eHl6e3x9fn+AgYKDhIWGh4iJiouMjY6P\n" + + "kJGSk5SVlpeYmZqbnJ2en6ChoqOkpaanqKmqq6ytrq+wsbKz\n" + + "tLW2t7i5uru8vb6/wMHCw8TFxsfIycrLzM3Oz9DR0tPU1dbX\n" + + "2Nna29zd3t/g4eLj5OXm5+jp6uvs7e7v8PHy8/T19vf4+fr7\n" + + "/P3+/w=="; + + public void test0CharInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(EMPTY_STRING))); + try { + reader.readUint8(); + fail("0 char"); + } catch (final EOFException e) { + assertEquals("0 char", 0, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test1CharInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR1))); + try { + reader.readUint8(); + fail("1 char"); + } catch (final EOFException e) { + assertEquals("1 char", 0, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test2CharsInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR2))); + try { + final int v1 = reader.readUint8(); + assertEquals("2 chars pos 0", 'A', v1); + reader.readUint8(); + fail("2 chars"); + } catch (final EOFException e) { + assertEquals("2 chars", 1, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test3CharsInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR3))); + try { + final int v1 = reader.readUint8(); + assertEquals("3 chars pos 0", 'A', v1); + final int v2 = reader.readUint8(); + assertEquals("3 chars pos 1", 'B', v2); + reader.readUint8(); + fail("3 chars"); + } catch (final EOFException e) { + assertEquals("3 chars", 2, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test4CharsInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(COMPLETE_CHAR4))); + try { + final int v1 = reader.readUint8(); + assertEquals("4 chars pos 0", 'A', v1); + final int v2 = reader.readUint8(); + assertEquals("4 chars pos 1", 'B', v2); + final int v3 = reader.readUint8(); + assertEquals("4 chars pos 2", 'C', v3); + reader.readUint8(); + fail("4 chars"); + } catch (final EOFException e) { + assertEquals("4 chars", 3, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void testAllBytePatternInt8() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(ALL_BYTE_PATTERN))); + try { + for (int i = 0; i <= 0xff; i++) { + final int v = reader.readUint8(); + assertEquals("value: all byte pattern: pos " + i, i, v); + assertEquals("count: all byte pattern: pos " + i, i + 1, reader.getByteCount()); + } + } catch (final EOFException e) { + assertEquals("all byte pattern", 256, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test0CharInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(EMPTY_STRING))); + try { + reader.readInt16(); + fail("0 char"); + } catch (final EOFException e) { + assertEquals("0 char", 0, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test1CharInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR1))); + try { + reader.readInt16(); + fail("1 char"); + } catch (final EOFException e) { + assertEquals("1 char", 0, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test2CharsInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR2))); + try { + reader.readInt16(); + fail("2 chars"); + } catch (final EOFException e) { + assertEquals("2 chars", 1, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test3CharsInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(INCOMPLETE_CHAR3))); + try { + final short v1 = reader.readInt16(); + assertEquals("3 chars pos 0", 'A' << 8 | 'B', v1); + reader.readInt16(); + fail("3 chars"); + } catch (final EOFException e) { + assertEquals("3 chars", 2, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void test4CharsInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(COMPLETE_CHAR4))); + try { + final short v1 = reader.readInt16(); + assertEquals("4 chars pos 0", 'A' << 8 | 'B', v1); + reader.readInt16(); + fail("4 chars"); + } catch (final EOFException e) { + assertEquals("4 chars", 3, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } + + public void testAllBytePatternInt16() { + final Base64Reader reader = new Base64Reader( + new LineNumberReader(new StringReader(ALL_BYTE_PATTERN))); + try { + for (int i = 0; i <= 0xff; i += 2) { + final short v = reader.readInt16(); + final short expected = (short)(i << 8 | (i + 1)); + assertEquals("value: all byte pattern: pos " + i, expected, v); + assertEquals("count: all byte pattern: pos " + i, i + 2, reader.getByteCount()); + } + } catch (final EOFException e) { + assertEquals("all byte pattern", 256, reader.getByteCount()); + } catch (final IOException e) { + fail("IOException: " + e); + } + } +} diff --git a/tests/src/com/android/inputmethod/latin/utils/CsvUtilsTests.java b/tests/src/com/android/inputmethod/latin/utils/CsvUtilsTests.java new file mode 100644 index 000000000..a0fa8fe4b --- /dev/null +++ b/tests/src/com/android/inputmethod/latin/utils/CsvUtilsTests.java @@ -0,0 +1,424 @@ +/* + * 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")); + } +} |