648 lines
34 KiB
Java
648 lines
34 KiB
Java
/*
|
|
* Copyright (C) 2010 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 static com.android.inputmethod.keyboard.internal.KeyboardIconsSet.ICON_UNDEFINED;
|
|
import static com.android.inputmethod.latin.Constants.CODE_OUTPUT_TEXT;
|
|
import static com.android.inputmethod.latin.Constants.CODE_UNSPECIFIED;
|
|
|
|
import android.test.AndroidTestCase;
|
|
import android.test.suitebuilder.annotation.SmallTest;
|
|
|
|
import com.android.inputmethod.latin.Constants;
|
|
|
|
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 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_NON_EXISTING = "!code/non_existing";
|
|
private static final String ICON_NON_EXISTING = "!icon/non_existing";
|
|
|
|
private int mCodeSettings;
|
|
private int mCodeActionNext;
|
|
private int mSettingsIconId;
|
|
|
|
@Override
|
|
protected void setUp() throws Exception {
|
|
super.setUp();
|
|
|
|
final String language = Locale.ENGLISH.getLanguage();
|
|
mCodesSet.setLanguage(language);
|
|
mTextsSet.setLanguage(language);
|
|
mTextsSet.loadStringResources(getContext());
|
|
|
|
mCodeSettings = KeySpecParser.parseCode(
|
|
CODE_SETTINGS, mCodesSet, CODE_UNSPECIFIED);
|
|
mCodeActionNext = KeySpecParser.parseCode(
|
|
"!code/key_action_next", mCodesSet, CODE_UNSPECIFIED);
|
|
mSettingsIconId = KeySpecParser.getIconId(ICON_SETTINGS);
|
|
}
|
|
|
|
private void assertParser(String message, String moreKeySpec, String expectedLabel,
|
|
String expectedOutputText, int expectedIcon, int expectedCode) {
|
|
final String labelResolved = KeySpecParser.resolveTextReference(moreKeySpec, mTextsSet);
|
|
final MoreKeySpec spec = new MoreKeySpec(labelResolved, false /* needsToUpperCase */,
|
|
Locale.US, mCodesSet);
|
|
assertEquals(message + " [label]", expectedLabel, spec.mLabel);
|
|
assertEquals(message + " [ouptputText]", expectedOutputText, spec.mOutputText);
|
|
assertEquals(message + " [icon]",
|
|
KeyboardIconsSet.getIconName(expectedIcon),
|
|
KeyboardIconsSet.getIconName(spec.mIconId));
|
|
assertEquals(message + " [code]",
|
|
Constants.printableCode(expectedCode),
|
|
Constants.printableCode(spec.mCode));
|
|
}
|
|
|
|
private void assertParserError(String message, String moreKeySpec, String expectedLabel,
|
|
String expectedOutputText, int expectedIcon, int expectedCode) {
|
|
try {
|
|
assertParser(message, moreKeySpec, expectedLabel, expectedOutputText, expectedIcon,
|
|
expectedCode);
|
|
fail(message);
|
|
} catch (Exception pcpe) {
|
|
// success.
|
|
}
|
|
}
|
|
|
|
// \U001d11e: MUSICAL SYMBOL G CLEF
|
|
private static final String PAIR1 = "\ud834\udd1e";
|
|
private static final int CODE1 = PAIR1.codePointAt(0);
|
|
// \U001d122: MUSICAL SYMBOL F CLEF
|
|
private static final String PAIR2 = "\ud834\udd22";
|
|
private static final int CODE2 = PAIR2.codePointAt(0);
|
|
// \U002f8a6: CJK COMPATIBILITY IDEOGRAPH-2F8A6; variant character of \u6148.
|
|
private static final String PAIR3 = "\ud87e\udca6";
|
|
private static final String SURROGATE1 = PAIR1 + PAIR2;
|
|
private static final String SURROGATE2 = PAIR1 + PAIR2 + PAIR3;
|
|
|
|
public void testSingleLetter() {
|
|
assertParser("Single letter", "a",
|
|
"a", null, ICON_UNDEFINED, 'a');
|
|
assertParser("Single surrogate", PAIR1,
|
|
PAIR1, null, ICON_UNDEFINED, CODE1);
|
|
assertParser("Single escaped bar", "\\|",
|
|
"|", null, ICON_UNDEFINED, '|');
|
|
assertParser("Single escaped escape", "\\\\",
|
|
"\\", null, ICON_UNDEFINED, '\\');
|
|
assertParser("Single comma", ",",
|
|
",", null, ICON_UNDEFINED, ',');
|
|
assertParser("Single escaped comma", "\\,",
|
|
",", null, ICON_UNDEFINED, ',');
|
|
assertParser("Single escaped letter", "\\a",
|
|
"a", null, ICON_UNDEFINED, 'a');
|
|
assertParser("Single escaped surrogate", "\\" + PAIR2,
|
|
PAIR2, null, ICON_UNDEFINED, CODE2);
|
|
assertParser("Single bang", "!",
|
|
"!", null, ICON_UNDEFINED, '!');
|
|
assertParser("Single escaped bang", "\\!",
|
|
"!", null, ICON_UNDEFINED, '!');
|
|
assertParser("Single output text letter", "a|a",
|
|
"a", null, ICON_UNDEFINED, 'a');
|
|
assertParser("Single surrogate pair outputText", "G Clef|" + PAIR1,
|
|
"G Clef", null, ICON_UNDEFINED, CODE1);
|
|
assertParser("Single letter with outputText", "a|abc",
|
|
"a", "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with surrogate outputText", "a|" + SURROGATE1,
|
|
"a", SURROGATE1, ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single surrogate with outputText", PAIR3 + "|abc",
|
|
PAIR3, "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with escaped outputText", "a|a\\|c",
|
|
"a", "a|c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with escaped surrogate outputText",
|
|
"a|" + PAIR1 + "\\|" + PAIR2,
|
|
"a", PAIR1 + "|" + PAIR2, ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with comma outputText", "a|a,b",
|
|
"a", "a,b", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with escaped comma outputText", "a|a\\,b",
|
|
"a", "a,b", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with outputText starts with bang", "a|!bc",
|
|
"a", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with surrogate outputText starts with bang", "a|!" + SURROGATE2,
|
|
"a", "!" + SURROGATE2, ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with outputText contains bang", "a|a!c",
|
|
"a", "a!c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single letter with escaped bang outputText", "a|\\!bc",
|
|
"a", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Single escaped escape with single outputText", "\\\\|\\\\",
|
|
"\\", null, ICON_UNDEFINED, '\\');
|
|
assertParser("Single escaped bar with single outputText", "\\||\\|",
|
|
"|", null, ICON_UNDEFINED, '|');
|
|
assertParser("Single letter with code", "a|" + CODE_SETTINGS,
|
|
"a", null, ICON_UNDEFINED, mCodeSettings);
|
|
}
|
|
|
|
public void testLabel() {
|
|
assertParser("Simple label", "abc",
|
|
"abc", "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Simple surrogate label", SURROGATE1,
|
|
SURROGATE1, SURROGATE1, ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped bar", "a\\|c",
|
|
"a|c", "a|c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Surrogate label with escaped bar", PAIR1 + "\\|" + PAIR2,
|
|
PAIR1 + "|" + PAIR2, PAIR1 + "|" + PAIR2,
|
|
ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped escape", "a\\\\c",
|
|
"a\\c", "a\\c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with comma", "a,c",
|
|
"a,c", "a,c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped comma", "a\\,c",
|
|
"a,c", "a,c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label starts with bang", "!bc",
|
|
"!bc", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Surrogate label starts with bang", "!" + SURROGATE1,
|
|
"!" + SURROGATE1, "!" + SURROGATE1, ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label contains bang", "a!c",
|
|
"a!c", "a!c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped bang", "\\!bc",
|
|
"!bc", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped letter", "\\abc",
|
|
"abc", "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with outputText", "abc|def",
|
|
"abc", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with comma and outputText", "a,c|def",
|
|
"a,c", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped comma label with outputText", "a\\,c|def",
|
|
"a,c", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped label with outputText", "a\\|c|def",
|
|
"a|c", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped bar outputText", "abc|d\\|f",
|
|
"abc", "d|f", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped escape label with outputText", "a\\\\|def",
|
|
"a\\", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label starts with bang and outputText", "!bc|def",
|
|
"!bc", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label contains bang label and outputText", "a!c|def",
|
|
"a!c", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped bang label with outputText", "\\!bc|def",
|
|
"!bc", "def", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with comma outputText", "abc|a,b",
|
|
"abc", "a,b", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped comma outputText", "abc|a\\,b",
|
|
"abc", "a,b", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with outputText starts with bang", "abc|!bc",
|
|
"abc", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with outputText contains bang", "abc|a!c",
|
|
"abc", "a!c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped bang outputText", "abc|\\!bc",
|
|
"abc", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with escaped bar outputText", "abc|d\\|f",
|
|
"abc", "d|f", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped bar label with escaped bar outputText", "a\\|c|d\\|f",
|
|
"a|c", "d|f", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with code", "abc|" + CODE_SETTINGS,
|
|
"abc", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParser("Escaped label with code", "a\\|c|" + CODE_SETTINGS,
|
|
"a|c", null, ICON_UNDEFINED, mCodeSettings);
|
|
}
|
|
|
|
public void testIconAndCode() {
|
|
assertParser("Icon with outputText", ICON_SETTINGS + "|abc",
|
|
null, "abc", mSettingsIconId, CODE_OUTPUT_TEXT);
|
|
assertParser("Icon with outputText starts with bang", ICON_SETTINGS + "|!bc",
|
|
null, "!bc", mSettingsIconId, CODE_OUTPUT_TEXT);
|
|
assertParser("Icon with outputText contains bang", ICON_SETTINGS + "|a!c",
|
|
null, "a!c", mSettingsIconId, CODE_OUTPUT_TEXT);
|
|
assertParser("Icon with escaped bang outputText", ICON_SETTINGS + "|\\!bc",
|
|
null, "!bc", mSettingsIconId, CODE_OUTPUT_TEXT);
|
|
assertParser("Label starts with bang and code", "!bc|" + CODE_SETTINGS,
|
|
"!bc", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParser("Label contains bang and code", "a!c|" + CODE_SETTINGS,
|
|
"a!c", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParser("Escaped bang label with code", "\\!bc|" + CODE_SETTINGS,
|
|
"!bc", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParser("Icon with code", ICON_SETTINGS + "|" + CODE_SETTINGS,
|
|
null, null, mSettingsIconId, mCodeSettings);
|
|
}
|
|
|
|
public void testResourceReference() {
|
|
assertParser("Settings as more key", "!text/settings_as_more_key",
|
|
null, null, mSettingsIconId, mCodeSettings);
|
|
|
|
assertParser("Action next as more key", "!text/label_next_key|!code/key_action_next",
|
|
"Next", null, ICON_UNDEFINED, mCodeActionNext);
|
|
|
|
assertParser("Popular domain",
|
|
"!text/keylabel_for_popular_domain|!text/keylabel_for_popular_domain ",
|
|
".com", ".com ", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
}
|
|
|
|
public void testFormatError() {
|
|
assertParserError("Empty spec", "", null,
|
|
null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Empty label with outputText", "|a",
|
|
null, "a", ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Empty label with code", "|" + CODE_SETTINGS,
|
|
null, null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParserError("Empty outputText with label", "a|",
|
|
"a", null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Empty outputText with icon", ICON_SETTINGS + "|",
|
|
null, null, mSettingsIconId, CODE_UNSPECIFIED);
|
|
assertParserError("Empty icon and code", "|",
|
|
null, null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Icon without code", ICON_SETTINGS,
|
|
null, null, mSettingsIconId, CODE_UNSPECIFIED);
|
|
assertParserError("Non existing icon", ICON_NON_EXISTING + "|abc",
|
|
null, "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParserError("Non existing code", "abc|" + CODE_NON_EXISTING,
|
|
"abc", null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Third bar at end", "a|b|",
|
|
"a", null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Multiple bar", "a|b|c",
|
|
"a", null, ICON_UNDEFINED, CODE_UNSPECIFIED);
|
|
assertParserError("Multiple bar with label and code", "a|" + CODE_SETTINGS + "|c",
|
|
"a", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParserError("Multiple bar with icon and outputText", ICON_SETTINGS + "|b|c",
|
|
null, null, mSettingsIconId, CODE_UNSPECIFIED);
|
|
assertParserError("Multiple bar with icon and code",
|
|
ICON_SETTINGS + "|" + CODE_SETTINGS + "|c",
|
|
null, null, mSettingsIconId, mCodeSettings);
|
|
}
|
|
|
|
public void testUselessUpperCaseSpecifier() {
|
|
assertParser("Single letter with CODE", "a|" + CODE_SETTINGS_UPPERCASE,
|
|
"a", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label with CODE", "abc|" + CODE_SETTINGS_UPPERCASE,
|
|
"abc", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped label with CODE", "a\\|c|" + CODE_SETTINGS_UPPERCASE,
|
|
"a|c", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("ICON with outputText", ICON_SETTINGS_UPPERCASE + "|abc",
|
|
"!ICON/SETTINGS_KEY", "abc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("ICON with outputText starts with bang", ICON_SETTINGS_UPPERCASE + "|!bc",
|
|
"!ICON/SETTINGS_KEY", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("ICON with outputText contains bang", ICON_SETTINGS_UPPERCASE + "|a!c",
|
|
"!ICON/SETTINGS_KEY", "a!c", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("ICON with escaped bang outputText", ICON_SETTINGS_UPPERCASE + "|\\!bc",
|
|
"!ICON/SETTINGS_KEY", "!bc", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label starts with bang and CODE", "!bc|" + CODE_SETTINGS_UPPERCASE,
|
|
"!bc", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Label contains bang and CODE", "a!c|" + CODE_SETTINGS_UPPERCASE,
|
|
"a!c", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("Escaped bang label with CODE", "\\!bc|" + CODE_SETTINGS_UPPERCASE,
|
|
"!bc", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("ICON with CODE", ICON_SETTINGS_UPPERCASE + "|" + CODE_SETTINGS_UPPERCASE,
|
|
"!ICON/SETTINGS_KEY", "!CODE/KEY_SETTINGS", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParser("SETTINGS AS MORE KEY", "!TEXT/SETTINGS_AS_MORE_KEY",
|
|
"!TEXT/SETTINGS_AS_MORE_KEY", "!TEXT/SETTINGS_AS_MORE_KEY", ICON_UNDEFINED,
|
|
CODE_OUTPUT_TEXT);
|
|
assertParser("ACTION NEXT AS MORE KEY", "!TEXT/LABEL_NEXT_KEY|!CODE/KEY_ACTION_NEXT",
|
|
"!TEXT/LABEL_NEXT_KEY", "!CODE/KEY_ACTION_NEXT", ICON_UNDEFINED,
|
|
CODE_OUTPUT_TEXT);
|
|
assertParser("POPULAR DOMAIN",
|
|
"!TEXT/KEYLABEL_FOR_POPULAR_DOMAIN|!TEXT/KEYLABEL_FOR_POPULAR_DOMAIN ",
|
|
"!TEXT/KEYLABEL_FOR_POPULAR_DOMAIN", "!TEXT/KEYLABEL_FOR_POPULAR_DOMAIN ",
|
|
ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParserError("Empty label with CODE", "|" + CODE_SETTINGS_UPPERCASE,
|
|
null, null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParserError("Empty outputText with ICON", ICON_SETTINGS_UPPERCASE + "|",
|
|
null, null, mSettingsIconId, CODE_UNSPECIFIED);
|
|
assertParser("ICON without code", ICON_SETTINGS_UPPERCASE,
|
|
"!ICON/SETTINGS_KEY", "!ICON/SETTINGS_KEY", ICON_UNDEFINED, CODE_OUTPUT_TEXT);
|
|
assertParserError("Multiple bar with label and CODE", "a|" + CODE_SETTINGS_UPPERCASE + "|c",
|
|
"a", null, ICON_UNDEFINED, mCodeSettings);
|
|
assertParserError("Multiple bar with ICON and outputText", ICON_SETTINGS_UPPERCASE + "|b|c",
|
|
null, null, mSettingsIconId, CODE_UNSPECIFIED);
|
|
assertParserError("Multiple bar with ICON and CODE",
|
|
ICON_SETTINGS_UPPERCASE + "|" + CODE_SETTINGS_UPPERCASE + "|c",
|
|
null, null, mSettingsIconId, mCodeSettings);
|
|
}
|
|
|
|
private static void assertArrayEquals(String message, Object[] expected, Object[] actual) {
|
|
if (expected == actual) {
|
|
return;
|
|
}
|
|
if (expected == null || actual == null) {
|
|
assertEquals(message, Arrays.toString(expected), Arrays.toString(actual));
|
|
return;
|
|
}
|
|
if (expected.length != actual.length) {
|
|
assertEquals(message + " [length]", Arrays.toString(expected), Arrays.toString(actual));
|
|
return;
|
|
}
|
|
for (int i = 0; i < expected.length; i++) {
|
|
assertEquals(message + " [" + i + "]",
|
|
Arrays.toString(expected), Arrays.toString(actual));
|
|
}
|
|
}
|
|
|
|
private static void assertInsertAdditionalMoreKeys(String message, String[] moreKeys,
|
|
String[] additionalMoreKeys, String[] expected) {
|
|
final String[] actual =
|
|
KeySpecParser.insertAdditionalMoreKeys( moreKeys, additionalMoreKeys);
|
|
assertArrayEquals(message, expected, actual);
|
|
}
|
|
|
|
public void testEmptyEntry() {
|
|
assertInsertAdditionalMoreKeys("null more keys and null additons",
|
|
null,
|
|
null,
|
|
null);
|
|
assertInsertAdditionalMoreKeys("null more keys and empty additons",
|
|
null,
|
|
new String[0],
|
|
null);
|
|
assertInsertAdditionalMoreKeys("empty more keys and null additons",
|
|
new String[0],
|
|
null,
|
|
null);
|
|
assertInsertAdditionalMoreKeys("empty more keys and empty additons",
|
|
new String[0],
|
|
new String[0],
|
|
null);
|
|
|
|
assertInsertAdditionalMoreKeys("filter out empty more keys",
|
|
new String[] { null, "a", "", "b", null },
|
|
null,
|
|
new String[] { "a", "b" });
|
|
assertInsertAdditionalMoreKeys("filter out empty additons",
|
|
new String[] { "a", "%", "b", "%", "c", "%", "d" },
|
|
new String[] { null, "A", "", "B", null },
|
|
new String[] { "a", "A", "b", "B", "c", "d" });
|
|
}
|
|
|
|
public void testInsertAdditionalMoreKeys() {
|
|
// Escaped marker.
|
|
assertInsertAdditionalMoreKeys("escaped marker",
|
|
new String[] { "\\%", "%-)" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2", "\\%", "%-)" });
|
|
|
|
// 0 more key.
|
|
assertInsertAdditionalMoreKeys("null & null", null, null, null);
|
|
assertInsertAdditionalMoreKeys("null & 1 additon",
|
|
null,
|
|
new String[] { "1" },
|
|
new String[] { "1" });
|
|
assertInsertAdditionalMoreKeys("null & 2 additons",
|
|
null,
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2" });
|
|
|
|
// 0 additional more key.
|
|
assertInsertAdditionalMoreKeys("1 more key & null",
|
|
new String[] { "A" },
|
|
null,
|
|
new String[] { "A" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & null",
|
|
new String[] { "A", "B" },
|
|
null,
|
|
new String[] { "A", "B" });
|
|
|
|
// No marker.
|
|
assertInsertAdditionalMoreKeys("1 more key & 1 addtional & no marker",
|
|
new String[] { "A" },
|
|
new String[] { "1" },
|
|
new String[] { "1", "A" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 addtionals & no marker",
|
|
new String[] { "A" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2", "A" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 1 addtional & no marker",
|
|
new String[] { "A", "B" },
|
|
new String[] { "1" },
|
|
new String[] { "1", "A", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 addtionals & no marker",
|
|
new String[] { "A", "B" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2", "A", "B" });
|
|
|
|
// 1 marker.
|
|
assertInsertAdditionalMoreKeys("1 more key & 1 additon & marker at head",
|
|
new String[] { "%", "A" },
|
|
new String[] { "1" },
|
|
new String[] { "1", "A" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 1 additon & marker at tail",
|
|
new String[] { "A", "%" },
|
|
new String[] { "1" },
|
|
new String[] { "A", "1" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 1 additon & marker at middle",
|
|
new String[] { "A", "%", "B" },
|
|
new String[] { "1" },
|
|
new String[] { "A", "1", "B" });
|
|
|
|
// 1 marker & excess additional more keys.
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 additons & marker at head",
|
|
new String[] { "%", "A", "B" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "A", "B", "2" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 additons & marker at tail",
|
|
new String[] { "A", "B", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "A", "B", "1", "2" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & marker at middle",
|
|
new String[] { "A", "%", "B" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "A", "1", "B", "2" });
|
|
|
|
// 2 markers.
|
|
assertInsertAdditionalMoreKeys("0 more key & 2 addtional & 2 markers",
|
|
new String[] { "%", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 addtional & 2 markers at head",
|
|
new String[] { "%", "%", "A" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "2", "A" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 addtional & 2 markers at tail",
|
|
new String[] { "A", "%", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "A", "1", "2" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 addtional & 2 markers at middle",
|
|
new String[] { "A", "%", "%", "B" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "A", "1", "2", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 addtional & 2 markers at head & middle",
|
|
new String[] { "%", "A", "%", "B" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "A", "2", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 addtional & 2 markers at head & tail",
|
|
new String[] { "%", "A", "B", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "A", "B", "2" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 addtional & 2 markers at middle & tail",
|
|
new String[] { "A", "%", "B", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "A", "1", "B", "2" });
|
|
|
|
// 2 markers & excess additional more keys.
|
|
assertInsertAdditionalMoreKeys("0 more key & 2 additons & 2 markers",
|
|
new String[] { "%", "%" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "1", "2", "3" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 additons & 2 markers at head",
|
|
new String[] { "%", "%", "A" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "1", "2", "A", "3" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 2 additons & 2 markers at tail",
|
|
new String[] { "A", "%", "%" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "A", "1", "2", "3" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & 2 markers at middle",
|
|
new String[] { "A", "%", "%", "B" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "A", "1", "2", "B", "3" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & 2 markers at head & middle",
|
|
new String[] { "%", "A", "%", "B" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "1", "A", "2", "B", "3" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & 2 markers at head & tail",
|
|
new String[] { "%", "A", "B", "%" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "1", "A", "B", "2", "3" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & 2 markers at middle & tail",
|
|
new String[] { "A", "%", "B", "%" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "A", "1", "B", "2", "3" });
|
|
|
|
// 0 addtional more key and excess markers.
|
|
assertInsertAdditionalMoreKeys("0 more key & null & excess marker",
|
|
new String[] { "%" },
|
|
null,
|
|
null);
|
|
assertInsertAdditionalMoreKeys("1 more key & null & excess marker at head",
|
|
new String[] { "%", "A" },
|
|
null,
|
|
new String[] { "A" });
|
|
assertInsertAdditionalMoreKeys("1 more key & null & excess marker at tail",
|
|
new String[] { "A", "%" },
|
|
null,
|
|
new String[] { "A" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & null & excess marker at middle",
|
|
new String[] { "A", "%", "B" },
|
|
null,
|
|
new String[] { "A", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & null & excess markers",
|
|
new String[] { "%", "A", "%", "B", "%" },
|
|
null,
|
|
new String[] { "A", "B" });
|
|
|
|
// Excess markers.
|
|
assertInsertAdditionalMoreKeys("0 more key & 1 additon & excess marker",
|
|
new String[] { "%", "%" },
|
|
new String[] { "1" },
|
|
new String[] { "1" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 1 additon & excess marker at head",
|
|
new String[] { "%", "%", "A" },
|
|
new String[] { "1" },
|
|
new String[] { "1", "A" });
|
|
assertInsertAdditionalMoreKeys("1 more key & 1 additon & excess marker at tail",
|
|
new String[] { "A", "%", "%" },
|
|
new String[] { "1" },
|
|
new String[] { "A", "1" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 1 additon & excess marker at middle",
|
|
new String[] { "A", "%", "%", "B" },
|
|
new String[] { "1" },
|
|
new String[] { "A", "1", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 1 additon & excess markers",
|
|
new String[] { "%", "A", "%", "B", "%" },
|
|
new String[] { "1" },
|
|
new String[] { "1", "A", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 2 additons & excess markers",
|
|
new String[] { "%", "A", "%", "B", "%" },
|
|
new String[] { "1", "2" },
|
|
new String[] { "1", "A", "2", "B" });
|
|
assertInsertAdditionalMoreKeys("2 more keys & 3 additons & excess markers",
|
|
new String[] { "%", "A", "%", "%", "B", "%" },
|
|
new String[] { "1", "2", "3" },
|
|
new String[] { "1", "A", "2", "3", "B" });
|
|
}
|
|
|
|
private static final String HAS_LABEL = "!hasLabel!";
|
|
private static final String NEEDS_DIVIDER = "!needsDividers!";
|
|
private static final String AUTO_COLUMN_ORDER = "!autoColumnOrder!";
|
|
private static final String FIXED_COLUMN_ORDER = "!fixedColumnOrder!";
|
|
|
|
private static void assertGetBooleanValue(String message, String key, String[] moreKeys,
|
|
String[] expected, boolean expectedValue) {
|
|
final String[] actual = Arrays.copyOf(moreKeys, moreKeys.length);
|
|
final boolean actualValue = KeySpecParser.getBooleanValue(actual, key);
|
|
assertEquals(message + " [value]", expectedValue, actualValue);
|
|
assertArrayEquals(message, expected, actual);
|
|
}
|
|
|
|
public void testGetBooleanValue() {
|
|
assertGetBooleanValue("Has label", HAS_LABEL,
|
|
new String[] { HAS_LABEL, "a", "b", "c" },
|
|
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[] { "!HASLABEL!", "a", "b", "c" }, false);
|
|
|
|
assertGetBooleanValue("No has label", HAS_LABEL,
|
|
new String[] { "a", "b", "c" },
|
|
new String[] { "a", "b", "c" }, false);
|
|
assertGetBooleanValue("No has label with fixed clumn order", HAS_LABEL,
|
|
new String[] { FIXED_COLUMN_ORDER + "3", "a", "b", "c" },
|
|
new String[] { FIXED_COLUMN_ORDER + "3", "a", "b", "c" }, false);
|
|
|
|
// Upper case specification will not work.
|
|
assertGetBooleanValue("Multiple has label", HAS_LABEL,
|
|
new String[] {
|
|
"a", HAS_LABEL.toUpperCase(), "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" },
|
|
new String[] {
|
|
"a", null, "b", NEEDS_DIVIDER, "!HASLABEL!", "d" }, true);
|
|
}
|
|
|
|
private static void assertGetIntValue(String message, String key, int defaultValue,
|
|
String[] moreKeys, String[] expected, int expectedValue) {
|
|
final String[] actual = Arrays.copyOf(moreKeys, moreKeys.length);
|
|
final int actualValue = KeySpecParser.getIntValue(actual, key, defaultValue);
|
|
assertEquals(message + " [value]", expectedValue, actualValue);
|
|
assertArrayEquals(message, expected, actual);
|
|
}
|
|
|
|
public void testGetIntValue() {
|
|
assertGetIntValue("Fixed column order 3", FIXED_COLUMN_ORDER, -1,
|
|
new String[] { FIXED_COLUMN_ORDER + "3", "a", "b", "c" },
|
|
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[] { "!FIXEDCOLUMNORDER!3", "a", "b", "c" }, -1);
|
|
|
|
assertGetIntValue("No fixed column order", FIXED_COLUMN_ORDER, -1,
|
|
new String[] { "a", "b", "c" },
|
|
new String[] { "a", "b", "c" }, -1);
|
|
assertGetIntValue("No fixed column order with auto column order", FIXED_COLUMN_ORDER, -1,
|
|
new String[] { AUTO_COLUMN_ORDER + "5", "a", "b", "c" },
|
|
new String[] { AUTO_COLUMN_ORDER + "5", "a", "b", "c" }, -1);
|
|
|
|
assertGetIntValue("Multiple fixed column order 3,5", FIXED_COLUMN_ORDER, -1,
|
|
new String[] { FIXED_COLUMN_ORDER + "3", "a", FIXED_COLUMN_ORDER + "5", "b" },
|
|
new String[] { null, "a", null, "b" }, 3);
|
|
// 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 + "3", "b" },
|
|
new String[] { "!FIXEDCOLUMNORDER!5", HAS_LABEL, "a", null, "b" }, 3);
|
|
}
|
|
}
|