summaryrefslogtreecommitdiffstats
path: root/qadevOOo/tests/java/ifc/i18n
diff options
context:
space:
mode:
Diffstat (limited to 'qadevOOo/tests/java/ifc/i18n')
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java679
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XCalendar.java523
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java398
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XCollator.java422
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java125
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java311
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java86
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java98
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XLocaleData.java467
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java154
-rw-r--r--qadevOOo/tests/java/ifc/i18n/_XTransliteration.java445
11 files changed, 3708 insertions, 0 deletions
diff --git a/qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java b/qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java
new file mode 100644
index 000000000..d33165fd7
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java
@@ -0,0 +1,679 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import java.util.ArrayList;
+
+import lib.MultiMethodTest;
+import lib.Status;
+import lib.StatusException;
+
+import com.sun.star.i18n.Boundary;
+import com.sun.star.i18n.LineBreakHyphenationOptions;
+import com.sun.star.i18n.LineBreakResults;
+import com.sun.star.i18n.LineBreakUserOptions;
+import com.sun.star.i18n.ScriptType;
+import com.sun.star.i18n.WordType;
+import com.sun.star.i18n.XBreakIterator;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XBreakIterator</code>
+* interface methods :
+* <ul>
+* <li><code> nextCharacters()</code></li>
+* <li><code> previousCharacters()</code></li>
+* <li><code> nextWord()</code></li>
+* <li><code> previousWord()</code></li>
+* <li><code> getWordBoundary()</code></li>
+* <li><code> getWordType()</code></li>
+* <li><code> isBeginWord()</code></li>
+* <li><code> isEndWord()</code></li>
+* <li><code> beginOfSentence()</code></li>
+* <li><code> endOfSentence()</code></li>
+* <li><code> getLineBreak()</code></li>
+* <li><code> beginOfScript()</code></li>
+* <li><code> endOfScript()</code></li>
+* <li><code> nextScript()</code></li>
+* <li><code> previousScript()</code></li>
+* <li><code> getScriptType()</code></li>
+* <li><code> beginOfCharBlock()</code></li>
+* <li><code> endOfCharBlock()</code></li>
+* <li><code> nextCharBlock()</code></li>
+* <li><code> previousCharBlock()</code></li>
+* </ul> <p>
+* This test needs the following object relations :
+* <ul>
+* <li> <code>'Locale'</code>
+* (of type <code>com.sun.star.lang.Locale</code>):
+* this locale is used as locale argument for tested methods.
+* </li>
+* <li> <code>'UnicodeString'</code>
+* (of type <code>String</code>): Unicode string which is passed
+* to methods except 'CharacterBlock' methods.
+* </li>
+* <ul> <p>
+* @see com.sun.star.i18n.XBreakIterator
+*/
+public class _XBreakIterator extends MultiMethodTest {
+
+ public XBreakIterator oObj = null;
+
+ Locale locale = null;
+ String UnicodeString = null;
+
+ short wordType = WordType.ANYWORD_IGNOREWHITESPACES;
+
+ /**
+ * Retrieves object relations.
+ * @throws StatusException If one of relations not found.
+ */
+ @Override
+ protected void before() {
+ locale = (Locale)tEnv.getObjRelation("Locale");
+ if (locale == null) {
+ throw new StatusException
+ (Status.failed("Relation 'Locale' not found")) ;
+ }
+
+ UnicodeString = (String)tEnv.getObjRelation("UnicodeString");
+ if (UnicodeString == null) {
+ throw new StatusException(Status.failed
+ ("Relation 'UnicodeString' not found")) ;
+ }
+ }
+
+ /**
+ * Compares returned next character positions with expected values. <p>
+ *
+ * Has <b>OK</b> status if position after travel and traveled length
+ * has expected values.
+ */
+ public void _nextCharacters() {
+ short nCharacterIteratorMode =
+ com.sun.star.i18n.CharacterIteratorMode.SKIPCHARACTER;
+
+ int strLength = UnicodeString.length();
+
+ //Start from position : Travel ... chars :
+ // Actual position after : How many chars traveled
+ int[][] nextCharacters = {
+ { 1, 5000, strLength , strLength - 1 },
+ { 10, 6, 16, 6}};
+
+ boolean bRes = true;
+
+ for(int i = 0; i < nextCharacters.length; i++) {
+ int[] lDone = new int[1];
+ long lRes = oObj.nextCharacters(UnicodeString, nextCharacters[i][0],
+ locale, nCharacterIteratorMode, nextCharacters[i][1], lDone);
+ log.println("Expected result is: lRes = " + nextCharacters[i][2] +
+ "; lDone = " + nextCharacters[i][3] );
+ log.println("Actual result is: lRes = " + lRes +
+ "; lDone = " + lDone[0] );
+
+ bRes = bRes && lRes == nextCharacters[i][2];
+ bRes = bRes && lDone[0] == nextCharacters[i][3];
+ }
+
+ tRes.tested("nextCharacters()", bRes);
+ }
+
+ /**
+ * Compares returned previous character positions with expected values. <p>
+ *
+ * Has <b>OK</b> status if position after travel and traveled length
+ * has expected values.
+ */
+ public void _previousCharacters() {
+ short nCharacterIteratorMode =
+ com.sun.star.i18n.CharacterIteratorMode.SKIPCHARACTER;
+
+
+ //Start from position : Travel ... chars : Actual position after :
+ //How many chars traveled
+ int[][] previousCharacters = {
+ {5, 5000, 0, 5},
+ {10, 6, 4, 6}};
+
+ boolean bRes = true;
+ for(int i = 0; i < previousCharacters.length; i++) {
+ int[] lDone = new int[1];
+ int lRes = oObj.previousCharacters(UnicodeString,
+ previousCharacters[i][0],
+ locale, nCharacterIteratorMode,
+ previousCharacters[i][1], lDone);
+ log.println("Expected result is: lRes = " + previousCharacters[i][2]
+ + "; lDone = " + previousCharacters[i][3] );
+ log.println("Actual result is: lRes = " + lRes
+ + "; lDone = " + lDone[0]);
+
+ bRes = bRes && lRes == previousCharacters[i][2];
+ bRes = bRes && lDone[0] == previousCharacters[i][3];
+ }
+
+ tRes.tested("previousCharacters()", bRes);
+ }
+
+ ArrayList<Boundary> vBounds = new ArrayList<Boundary>();
+
+ /**
+ * Saves bounds of all returned words for the future tests. <p>
+ * Has <b>OK</b> status.
+ */
+ public void _nextWord() {
+ int i = 0;
+
+ while( i < UnicodeString.length() - 1 ) {
+ Boundary bounds = oObj.nextWord
+ (UnicodeString, i, locale, wordType);
+ if (bounds.endPos - bounds.startPos > 3) {
+ vBounds.add( bounds );
+ log.println("Word " + vBounds.size() + "("
+ + bounds.startPos + "," + bounds.endPos + "): '" +
+ UnicodeString.substring(bounds.startPos,
+ bounds.endPos) + "'");
+ }
+ i = bounds.endPos - 1;
+ }
+ log.println("In text there are " + vBounds.size()
+ + " words, if count from left to right");
+ tRes.tested("nextWord()", true);
+ }
+
+ /**
+ * Compares number of word bounds with number of word bounds saved
+ * by the method _nextWord().<p>
+ * Has <b>OK</b> status if number of word bounds are equal.
+ */
+ public void _previousWord() {
+ requiredMethod("nextWord()");
+
+ int i = UnicodeString.length() - 1;
+ ArrayList<Boundary> vPrevBounds = new ArrayList<Boundary>();
+ while( i > 0 ) {
+ Boundary bounds =
+ oObj.previousWord(UnicodeString, i, locale, wordType);
+ if (bounds.endPos - bounds.startPos > 3) {
+ vPrevBounds.add( bounds );
+ log.println("Word " + vPrevBounds.size() + "("
+ + bounds.startPos + "," + bounds.endPos + "): '"
+ + UnicodeString.substring(bounds.startPos, bounds.endPos)
+ + "'");
+ }
+ i = bounds.startPos;
+ }
+ log.println("In text there are " + vPrevBounds.size()
+ + " words, if count from right to left");
+ tRes.tested("previousWord()", vPrevBounds.size() == vBounds.size() );
+ }
+
+ /**
+ * For every word in array obtained by <code>nextWord</code> method test
+ * computes bounds of the word, passing its internal character position.<p>
+ *
+ * Has <b>OK</b> status if bounds calculated by <code>getWordBoundary()</code>
+ * method are the same as bounds obtained by <code>nextWord</code> method.
+ */
+ public void _getWordBoundary() {
+ requiredMethod("nextWord()");
+
+ boolean bRes = true;
+
+ for(int i = 0; i < vBounds.size(); i++) {
+ // calculate middle of the word
+ Boundary iBounds = vBounds.get(i);
+ int iPos = (iBounds.endPos - iBounds.startPos) / 2
+ + iBounds.startPos;
+ Boundary bounds = oObj.getWordBoundary(UnicodeString, iPos,
+ locale, wordType, true);
+ log.println("Expected result is: startPos = " + iBounds.startPos +
+ "; endPos = " + iBounds.endPos);
+ log.println("Actual result is: startPos = " + bounds.startPos
+ + "; endPos = " + bounds.endPos + " Word is: '"
+ + UnicodeString.substring(bounds.startPos, bounds.endPos) + "'");
+
+ bRes = bRes && iBounds.startPos == bounds.startPos;
+ bRes = bRes && iBounds.endPos == bounds.endPos;
+ }
+
+ tRes.tested("getWordBoundary()", bRes);
+ }
+
+ /**
+ * For every word in array obtained by <code>nextWord</code> method test
+ * get its type, passing its internal character position.<p>
+ *
+ * Has <b>OK</b> status if every word has type <code>WordType.ANY_WORD</code>
+ */
+ public void _getWordType() {
+ requiredMethod("nextWord()");
+
+ boolean bRes = true;
+
+ for(int i = 0; i < vBounds.size(); i++) {
+ // calculate middle of the word
+ Boundary iBounds = vBounds.get(i);
+ int iPos = (iBounds.endPos - iBounds.startPos) / 2
+ + iBounds.startPos;
+
+ short type = oObj.getWordType(UnicodeString, iPos, locale);
+
+ bRes = bRes && type == WordType.ANY_WORD;
+ }
+
+ tRes.tested("getWordType()", bRes);
+ }
+
+ /**
+ * For every word in array obtained by <code>nextWord</code> method test
+ * tries to determine if the character at a position starts a word.
+ * First word starting position is passed, then internal character
+ * position is passed. <p>
+ * Has <b>OK</b> status if in the first case <code>true</code>
+ * returned and in the second - <code>false</code> for every word.
+ */
+ public void _isBeginWord() {
+ requiredMethod("nextWord()");
+
+ boolean bRes = true;
+
+ for(int i = 0; i < vBounds.size(); i++) {
+ Boundary iBounds = vBounds.get(i);
+ boolean isBegin = oObj.isBeginWord(UnicodeString, iBounds.startPos,
+ locale, WordType.ANY_WORD);
+ bRes = bRes && isBegin;
+ boolean isNotBegin = !oObj.isBeginWord(UnicodeString,
+ iBounds.startPos + 1, locale, WordType.ANY_WORD);
+ bRes = bRes && isNotBegin;
+
+ log.println("At position + " + iBounds.startPos
+ + " isBeginWord? " + isBegin);
+ log.println("At position + " + (iBounds.startPos + 1)
+ + " isBeginWord? " + !isNotBegin);
+ }
+
+ tRes.tested("isBeginWord()", bRes);
+ }
+
+ /**
+ * For every word in array obtained by <code>nextWord</code> method test
+ * tries to determine if the character at a position ends a word.
+ * First word ending position is passed, then internal character
+ * position is passed. <p>
+ *
+ * Has <b>OK</b> status if in the first case <code>true</code>
+ * returned and in the second - <code>false</code> for every word.
+ */
+ public void _isEndWord() {
+ requiredMethod("nextWord()");
+
+ boolean bRes = true;
+
+ for(int i = 0; i < vBounds.size(); i++) {
+ Boundary iBounds = vBounds.get(i);
+ boolean isEnd = oObj.isEndWord(UnicodeString, iBounds.endPos,
+ locale, WordType.ANY_WORD);
+ bRes = bRes && isEnd;
+ boolean isNotEnd = !oObj.isEndWord(UnicodeString,
+ iBounds.endPos - 1, locale, WordType.ANY_WORD);
+ bRes = bRes && isNotEnd;
+
+ log.println("At position + " + iBounds.endPos
+ + " isEndWord? " + isEnd);
+ log.println("At position + " + (iBounds.endPos - 1)
+ + " isEndWord? " + !isNotEnd);
+ }
+
+ tRes.tested("isEndWord()", bRes);
+ }
+
+ ArrayList<Integer> vSentenceStart = new ArrayList<Integer>();
+ /**
+ * Tries to find all sentences starting positions passing every character
+ * as position parameter and stores them. Then tries to pass invalid
+ * position parameters.
+ *
+ * Has <b>OK</b> status if -1 is returned for wrong position arguments.
+ */
+ public void _beginOfSentence() {
+ int iPos = 0;
+ while( iPos < UnicodeString.length() ) {
+ Integer start = Integer.valueOf( oObj.beginOfSentence(UnicodeString,
+ iPos, locale) );
+ if (start.intValue() >= 0 && !vSentenceStart.contains(start) ) {
+ vSentenceStart.add( start );
+ log.println("Sentence " + vSentenceStart.size()
+ + " : start from position " + start);
+ }
+ iPos++;
+ }
+
+ //test for invalid nStartPosition
+ boolean bRes = oObj.beginOfSentence(UnicodeString, -10, locale) == -1;
+ bRes &= oObj.beginOfSentence(UnicodeString,
+ UnicodeString.length() + 1, locale) == -1;
+
+ if (!bRes) {
+ log.println("When invalid position, returned value isn't equal to -1");
+ }
+
+ tRes.tested("beginOfSentence()", bRes);
+ }
+
+ /**
+ * For every sentence starting position found in
+ * <code>beginOfSentence()</code> test tries to compute end
+ * position of a sentence and checks that the end position is
+ * greater than starting.
+ * Then wrong position arguments are passed.
+ *
+ * Has <b>OK</b> status if the end position of every sentence
+ * greater than starting and -1 returned for invalid arguments.
+ */
+ public void _endOfSentence() {
+ boolean bRes = true;
+ for(int i = 0; i < vSentenceStart.size(); i++) {
+ int start = vSentenceStart.get(i).intValue();
+ int end = oObj.endOfSentence(UnicodeString, start, locale);
+ bRes &= end > start;
+ log.println("Sentence " + i + " range is [" + start + ", "
+ + end + "]");
+ }
+
+ //test for invalid nStartPosition
+ boolean bInvRes = oObj.endOfSentence(UnicodeString, -10, locale) == -1;
+ bInvRes &= oObj.endOfSentence(UnicodeString,
+ UnicodeString.length() + 1, locale) == -1;
+
+ if (!bInvRes) {
+ log.println("When invalid position, returned value isn't equal to -1");
+ }
+
+ tRes.tested("endOfSentence()", bRes && bInvRes);
+ }
+
+ /**
+ * Tries to break a string in position other than 0 iterating characters
+ * from the string beginning (Hyphenation is not used for a while). <p>
+ *
+ * Has <b>OK</b> status if non-zero break position was found and it is
+ * less or equal than position we trying to break.
+ */
+ public void _getLineBreak() {
+ boolean bRes = true;
+ LineBreakResults lineBreakResults;
+ LineBreakHyphenationOptions lineBreakHyphenationOptions =
+ new LineBreakHyphenationOptions();
+ LineBreakUserOptions lineBreakUserOptions = new LineBreakUserOptions();
+
+ lineBreakUserOptions.applyForbiddenRules = false;
+ lineBreakUserOptions.allowHyphenateEnglish = false;
+
+ int breakPos = 0;
+ int pos = 0;
+
+ while(breakPos == 0 && pos < UnicodeString.length() ) {
+ lineBreakResults = oObj.getLineBreak(UnicodeString, pos,
+ locale, 0, lineBreakHyphenationOptions, lineBreakUserOptions);
+ breakPos = lineBreakResults.breakIndex;
+ pos++;
+ }
+
+ // finally the position of break must be found in the middle and
+ // it must be before the break position specified
+ bRes = breakPos <= pos && breakPos > 0;
+
+ if (!bRes) {
+ log.println("The last position was: " + pos
+ + ", and the break position was: " + breakPos);
+ }
+
+ tRes.tested("getLineBreak()", bRes);
+ }
+
+ // Asian type script
+ private static String katakana = new String(new char[] {0x30A1, 0x30A2}) ;
+ // Weak type script
+ private static String arrows = new String(new char[] {0x2190, 0x2191}) ;
+ // Complex type script
+ private static String arabic = new String(new char[] {0x0641, 0x0642}) ;
+
+ /**
+ * Tries to find the beginning of the nearest script specified
+ * relatively to position passed. <p>
+ * Has <b>OK</b> status if the starting position of script is returned.
+ */
+ public void _beginOfScript() {
+ String multiScript = "ab" + katakana ;
+
+ int pos = oObj.beginOfScript(multiScript, 3, ScriptType.ASIAN) ;
+
+ log.println("Position = " + pos) ;
+
+ tRes.tested("beginOfScript()", pos == 2) ;
+ }
+
+ /**
+ * Tries to find the end of the nearest script specified
+ * relatively to position passed. <p>
+ * Has <b>OK</b> status if the end position of script is returned.
+ */
+ public void _endOfScript() {
+ String multiScript = "ab" + katakana + "cd" ;
+
+ int pos = oObj.endOfScript(multiScript, 2, ScriptType.ASIAN) ;
+
+ log.println("Position = " + pos) ;
+
+ tRes.tested("endOfScript()", pos == 4) ;
+ }
+
+ /**
+ * Tries to find the next script starting position specified
+ * relatively to position passed. <p>
+ * Has <b>OK</b> status if the appropriate position is returned.
+ */
+ public void _nextScript() {
+ String multiScript = "ab" + katakana + "cd" ;
+
+ int pos = oObj.nextScript(multiScript, 0, ScriptType.LATIN) ;
+
+ log.println("Position = " + pos) ;
+
+ tRes.tested("nextScript()", pos == 4) ;
+ }
+
+ /**
+ * Tries to find the previous script starting position specified
+ * relatively to position passed. <p>
+ * Has <b>OK</b> status if the appropriate position is returned.
+ */
+ public void _previousScript() {
+ String multiScript = "ab" + katakana + "cd" ;
+
+ int pos = oObj.previousScript(multiScript, 5, ScriptType.ASIAN) ;
+
+ log.println("Position = " + pos) ;
+
+ tRes.tested("previousScript()", pos == 2) ;
+ }
+
+ /**
+ * Tries to determine script type (of all four types). <p>
+ * Has <b>OK</b> status if <code>LATIN</code> type returned
+ * for ASCII character, <code>ASIAN</code> for Katakana Unicode
+ * codepoints, <code>COMPLEX</code> for Arabic Unicode
+ * codepoints and <code>WEAK</code> for codepoints from Arrows
+ * Unicode block.
+ */
+ public void _getScriptType() {
+ boolean res = true ;
+
+ res &= oObj.getScriptType("abcd", 0) == ScriptType.LATIN ;
+ res &= oObj.getScriptType(katakana, 0) == ScriptType.ASIAN;
+ res &= oObj.getScriptType(arabic, 0) == ScriptType.COMPLEX ;
+ res &= oObj.getScriptType(arrows, 0) == ScriptType.WEAK ;
+
+ tRes.tested("getScriptType()", res) ;
+ }
+
+ boolean bCharBlockRes = true;
+
+ protected short getCharBlockType(int pos) {
+ short i = 1;
+ short cType = 0;
+ while (i < 31) {
+ if (oObj.beginOfCharBlock(UnicodeString, pos, locale, i) != -1) {
+ cType = i;
+ i = 100;
+ }
+ i++;
+ }
+
+ return cType;
+ }
+
+ ArrayList<Boundary> vCharBlockBounds = new ArrayList<Boundary>();
+ ArrayList<Short> vCharBlockTypes = new ArrayList<Short>();
+
+ /**
+ * Creates array of all char blocks with their boundaries and
+ * types using <code>beginOfCharBlock()</code> and
+ * <code>endOfCharBlock()</code> methods. <p>
+ *
+ * Has <b>OK</b> status if the end of each boundary is the same
+ * as start of the next one and if the start of the first block
+ * has position 0 and the end of the last block is at the end
+ * of the whole string.
+ */
+ public void _beginOfCharBlock() {
+ int iPos = 0;
+
+ while( iPos < UnicodeString.length() && iPos > -1) {
+ short charType = getCharBlockType(iPos);
+ int startPos = oObj.beginOfCharBlock(UnicodeString, iPos,
+ locale, charType);
+ int endPos = oObj.endOfCharBlock(UnicodeString, iPos,
+ locale, charType);
+ iPos = endPos;
+ vCharBlockBounds.add(new Boundary(startPos, endPos));
+ log.println(vCharBlockBounds.size() + "). Bounds: ["
+ + startPos + "," + endPos + "]; Type = " + charType);
+ vCharBlockTypes.add(Short.valueOf(charType));
+ }
+
+ for(int i = 0; i < vCharBlockBounds.size() - 1; i++) {
+ int endPos = vCharBlockBounds.get(i).endPos;
+ int startPos = vCharBlockBounds.get(i + 1).startPos;
+ if (endPos != startPos) {
+ bCharBlockRes = false;
+ }
+ }
+
+ log.println("Testing for no intersections : " + bCharBlockRes);
+ int startPos = vCharBlockBounds.get(0).startPos;
+ if (startPos != 0) {
+ bCharBlockRes = false;
+ }
+ int endPos = vCharBlockBounds.get
+ (vCharBlockBounds.size() - 1).endPos;
+ if (endPos != UnicodeString.length()) {
+ bCharBlockRes = false;
+ }
+ log.println("Regions should starts with 0 and ends with "
+ + UnicodeString.length());
+
+ tRes.tested("beginOfCharBlock()", bCharBlockRes);
+ }
+
+ /**
+ * Testing of this method is performed in <code>beginOfCharBlock()</code>
+ * method test. <p>
+ *
+ * Has the status same as <code>beginOfCharBlock()</code> method status.
+ */
+ public void _endOfCharBlock() {
+ requiredMethod("beginOfCharBlock()");
+ tRes.tested("endOfCharBlock()", bCharBlockRes);
+ }
+
+ /**
+ * For every character block obtained in <code>beginOfCharBlock()</code>
+ * method test (except the first) tries to find its starting position
+ * by mean of <code>nextCharBlock()</code> method passing as position
+ * argument the position before the start of a block. <p>
+ *
+ * Has <b>OK</b> status if the start of every block was found and it's
+ * equal to this block boundary start.
+ */
+ public void _nextCharBlock() {
+ requiredMethod("beginOfCharBlock()");
+
+ boolean bRes = true;
+ for(int i = 0; i < vCharBlockBounds.size(); i++) {
+ Boundary bounds = vCharBlockBounds.get(i);
+ Short type = vCharBlockTypes.get(i);
+ if (bounds.startPos - 1 < 0) continue;
+ int iPos = oObj.nextCharBlock(UnicodeString, bounds.startPos - 1,
+ locale, type.shortValue());
+ if (iPos != bounds.startPos) {
+ bRes = false;
+ log.println("nextCharBlock(UnicodeString, "
+ + (bounds.startPos - 1) + ", locale, " + type
+ + ") should return " + bounds.startPos);
+ log.println("... and actual value is " + iPos);
+ }
+ }
+
+ tRes.tested("nextCharBlock()", bRes);
+ }
+
+ /**
+ * For every character block obtained in <code>beginOfCharBlock()</code>
+ * method test (except the first) tries to find its starting position
+ * by mean of <code>previousCharBlock()</code> method passing as position
+ * argument the position after the end of a block. <p>
+ *
+ * Has <b>OK</b> status if the start of every block was found and it's
+ * equal to this block boundary start.
+ */
+ public void _previousCharBlock() {
+ requiredMethod("beginOfCharBlock()");
+
+ boolean bRes = true;
+ for(int i = 0; i < vCharBlockBounds.size(); i++) {
+ Boundary bounds = vCharBlockBounds.get(i);
+ Short type = vCharBlockTypes.get(i);
+ int iPos = oObj.previousCharBlock(UnicodeString,
+ bounds.endPos + 1, locale, type.shortValue());
+ if (iPos != bounds.startPos) {
+ bRes = false;
+ log.println("previousCharBlock(UnicodeString, "
+ + (bounds.endPos + 1) + ", locale, " + type
+ + ") should return " + bounds.startPos);
+ log.println("... and actual value is " + iPos);
+ }
+ }
+
+ tRes.tested("previousCharBlock()", bRes);
+ }
+
+}
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XCalendar.java b/qadevOOo/tests/java/ifc/i18n/_XCalendar.java
new file mode 100644
index 000000000..d24f20122
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XCalendar.java
@@ -0,0 +1,523 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.CalendarDisplayIndex;
+import com.sun.star.i18n.CalendarFieldIndex;
+import com.sun.star.i18n.CalendarItem;
+import com.sun.star.i18n.XCalendar;
+import com.sun.star.i18n.XLocaleData;
+import com.sun.star.lang.Locale;
+import com.sun.star.uno.UnoRuntime;
+
+/**
+* Testing <code>com.sun.star.i18n.XCalendar</code>
+* interface methods :
+* <ul>
+* <li><code> loadDefaultCalendar()</code></li>
+* <li><code> loadCalendar()</code></li>
+* <li><code> getLoadedCalendar()</code></li>
+* <li><code> getAllCalendars()</code></li>
+* <li><code> getUniqueID()</code></li>
+* <li><code> setDateTime()</code></li>
+* <li><code> getDateTime()</code></li>
+* <li><code> setValue()</code></li>
+* <li><code> getValue()</code></li>
+* <li><code> isValid()</code></li>
+* <li><code> addValue()</code></li>
+* <li><code> getFirstDayOfWeek()</code></li>
+* <li><code> setFirstDayOfWeek()</code></li>
+* <li><code> setMinimumNumberOfDaysForFirstWeek()</code></li>
+* <li><code> getMinimumNumberOfDaysForFirstWeek()</code></li>
+* <li><code> getNumberOfMonthsInYear()</code></li>
+* <li><code> getNumberOfDaysInWeek()</code></li>
+* <li><code> getMonths()</code></li>
+* <li><code> getDays()</code></li>
+* <li><code> getDisplayName()</code></li>
+* </ul> <p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XCalendar
+*/
+public class _XCalendar extends MultiMethodTest {
+ private boolean debug = false;
+ public XCalendar oObj = null;
+ public String[][] calendars;
+ public int[] count;
+ public double newDTime = 1000.75;
+ public short newValue = 2;
+ public short firstDay = 2;
+ public short mdfw = 3;
+ double aOriginalDTime = 0;
+ Locale[] installed_locales;
+
+ @Override
+ public void before() {
+ XLocaleData locData = null;
+ try {
+ locData = UnoRuntime.queryInterface(
+ XLocaleData.class,
+ tParam.getMSF().createInstance(
+ "com.sun.star.i18n.LocaleData"));
+
+ installed_locales = locData.getAllInstalledLocaleNames();
+ calendars = new String[installed_locales.length][];
+ count = new int[installed_locales.length];
+ } catch (com.sun.star.uno.Exception e) {
+
+ }
+
+ oObj.loadDefaultCalendar(installed_locales[0]);
+ aOriginalDTime = oObj.getDateTime();
+ debug = tParam.getBool("DebugIsActive");
+ }
+
+ /**
+ * Restore the changed time during the test to the original value of the
+ * machine: has to be correct for the following interface tests.
+ */
+ @Override
+ public void after() {
+ oObj.loadDefaultCalendar(installed_locales[0]);
+ oObj.setDateTime(aOriginalDTime);
+ }
+
+ /**
+ * Loads default calendar for different locales. <p>
+ * Has <b> OK </b> status if method loads calendar, that is
+ * default for a given locale.
+ */
+ public void _loadDefaultCalendar() {
+ boolean res = true;
+
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.loadDefaultCalendar(installed_locales[i]);
+ if (!oObj.getLoadedCalendar().Default) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= oObj.getLoadedCalendar().Default;
+ }
+
+ tRes.tested("loadDefaultCalendar()", res);
+ }
+
+ /**
+ * Tries to obtain calendars for a number of locales. <p>
+ * Has <b> OK </b> status if the method returns more than zero calendars for
+ * every locale.
+ */
+ public void _getAllCalendars() {
+ boolean res = true;
+
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ calendars[i] = oObj.getAllCalendars(installed_locales[i]);
+ count[i] = calendars[i].length-1;
+ if (calendars[i].length <= 0) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= (calendars[i].length > 0);
+ }
+ tRes.tested("getAllCalendars()", res);
+ }
+
+ /**
+ * Loads calendars for a number of locales. <p>
+ * Has <b> OK </b> status if loaded calendar names are equal to gotten
+ * calendar names after loading.<p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> getAllCalendars() </code> : gets all calendars for a given
+ * locale </li>
+ * </ul>
+ */
+ public void _loadCalendar() {
+ boolean res = true;
+ requiredMethod("getAllCalendars()");
+
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.loadCalendar(calendars[i][0], installed_locales[i]);
+ if (!calendars[i][0].equals(oObj.getLoadedCalendar().Name)) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= calendars[i][0].equals(oObj.getLoadedCalendar().Name);
+ }
+
+ tRes.tested("loadCalendar()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if loaded calendar names are equal to gotten
+ * calendar names after loading.<p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> loadCalendar() </code> : loads calendar using a given name
+ * and locale </li>
+ * </ul>
+ */
+ public void _getLoadedCalendar() {
+ boolean res = true;
+
+ requiredMethod("loadCalendar()");
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.loadCalendar(calendars[i][0], installed_locales[i]);
+ if (!calendars[i][0].equals(oObj.getLoadedCalendar().Name)) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= calendars[i][0].equals(oObj.getLoadedCalendar().Name);
+ }
+ tRes.tested("getLoadedCalendar()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value that's equal to a
+ * calendar name. <p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> loadCalendar() </code> : loads calendar using a given name
+ * and locale </li>
+ * </ul>
+ */
+ public void _getUniqueID() {
+ boolean res = true;
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.loadCalendar(calendars[i][0], installed_locales[i]);
+ String uID = oObj.getUniqueID();
+ if (!uID.equals(calendars[i][0])) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= uID.equals(calendars[i][0]);
+ }
+
+ tRes.tested("getUniqueID()",res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value, that's equal to
+ * value set before. <p>
+ */
+
+ public void _setDateTime() {
+ boolean res = true;
+
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.setDateTime(newDTime);
+ double aDTime = oObj.getDateTime();
+ if (aDTime != newDTime) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= (aDTime == newDTime);
+ }
+
+ tRes.tested("setDateTime()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value, that's equal to
+ * value set before. <p>
+ */
+
+ public void _getDateTime() {
+ boolean res = true;
+
+ for (int i=0; i<installed_locales.length; i++) {
+ String lang = "Language: "+installed_locales[i].Language +
+ ", Country: "+ installed_locales[i].Country +
+ ", Variant: "+ installed_locales[i].Country;
+ oObj.setDateTime(newDTime);
+ double aDTime = oObj.getDateTime();
+ if (aDTime != newDTime) {
+ log.println(lang + " ... FAILED");
+ }
+ res &= (aDTime == newDTime);
+ }
+ tRes.tested("getDateTime()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value, that's equal to
+ * value set before. <p>
+ */
+ public void _setValue() {
+ boolean res = true;
+ for (int i = 0; i < installed_locales.length; i++) {
+ String error = "";
+ String lang = "Language: " + installed_locales[i].Language + ", Country: " + installed_locales[i].Country
+ + ", Variant: " + installed_locales[i].Variant + ", Name: " + calendars[i][count[i]];
+ String[] names = new String[] { "DAY_OF_MONTH", "HOUR", "MINUTE", "SECOND", "MILLISECOND", "YEAR",
+ "MONTH" };
+ oObj.loadCalendar(calendars[i][count[i]], installed_locales[i]);
+ short[] fields = new short[] { CalendarFieldIndex.DAY_OF_MONTH, CalendarFieldIndex.HOUR,
+ CalendarFieldIndex.MINUTE, CalendarFieldIndex.SECOND, CalendarFieldIndex.MILLISECOND,
+ CalendarFieldIndex.YEAR, CalendarFieldIndex.MONTH };
+ for (int k = 0; k < fields.length; k++) {
+
+ oObj.setDateTime(0.0);
+
+ // save the current values for debug purposes
+ short[] oldValues = new short[fields.length];
+ for (int n = 0; n < oldValues.length; n++) {
+ oldValues[n] = oObj.getValue(fields[n]);
+ }
+
+ short set = oObj.getValue(fields[k]);
+ if (fields[k] == CalendarFieldIndex.MONTH)
+ set = newValue;
+ oObj.setValue(fields[k], set);
+ short get = oObj.getValue(fields[k]);
+ if (get != set) {
+ if (debug)
+ log.println("ERROR occurred: tried to set " + names[k] + " to value " + set);
+ log.println("list of values BEFORE set " + names[k] + " to value " + set + ":");
+ for (int n = 0; n < oldValues.length; n++) {
+ log.println(names[n] + ":" + oldValues[n]);
+ }
+ log.println("list of values AFTER set " + names[k] + " to value " + set + ":");
+ for (int n = 0; n < fields.length; n++) {
+ log.println(names[n] + ":" + oObj.getValue(fields[n]));
+ }
+
+ error += "failed for " + names[k] + " expected " + set + " gained " + get + " ; \n";
+ }
+ }
+ if (error.equals("")) {
+ log.println(lang + " ... OK");
+ } else {
+ log.println("*** " + lang + " ... FAILED ***");
+ log.println(error);
+ }
+ res &= error.equals("");
+ }
+
+ tRes.tested("setValue()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value, that's equal to
+ * value set before. <p>
+ */
+
+ public void _getValue() {
+ boolean res = true;
+
+ requiredMethod("setValue()");
+ short aValue = oObj.getValue(CalendarFieldIndex.MONTH);
+ res &= (aValue == newValue);
+ if (!res){
+ log.println("the returned value is not the expected value:");
+ log.println("expected: " + newValue + " returned value: " + aValue);
+ }
+ tRes.tested("getValue()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if value, added by the method is greater than
+ * previously defined "newValue".
+ * <p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> getValue() </code> : gets the value of a field </li>
+ * </ul>
+ */
+ public void _addValue() {
+ boolean res = true;
+
+ requiredMethod("getValue()");
+ oObj.addValue(CalendarFieldIndex.MONTH, 1);
+ short aValue = oObj.getValue(CalendarFieldIndex.MONTH);
+ res &= (aValue > newValue);
+ if (!res){
+ log.println("the returned value is not the expected value:");
+ log.println("expected: " + newValue + " returned value: " + aValue);
+ }
+ tRes.tested("addValue()", res);
+ }
+
+ /**
+ * Test calls the method. <p>
+ * Has <b> OK </b> status if the method successfully returns
+ * and no exceptions were thrown.
+ */
+ public void _setFirstDayOfWeek() {
+ boolean res = true;
+
+ oObj.setFirstDayOfWeek(firstDay);
+ res &= true;
+ tRes.tested("setFirstDayOfWeek()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value that is equal to
+ * value set before. <p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> setFirstDayOfWeek() </code> : set the first day of a
+ * week</li>
+ * </ul>
+ */
+ public void _getFirstDayOfWeek() {
+ boolean res = true;
+
+ requiredMethod("setFirstDayOfWeek()");
+ short aFirstDayOfWeek = oObj.getFirstDayOfWeek();
+ res &= (aFirstDayOfWeek == firstDay);
+ tRes.tested("getFirstDayOfWeek()", res);
+ }
+
+ /**
+ * Test calls the method. <p>
+ * Has <b> OK </b> status if the method successfully returns
+ * and no exceptions were thrown.
+ */
+ public void _setMinimumNumberOfDaysForFirstWeek() {
+ boolean res = true;
+
+ oObj.setMinimumNumberOfDaysForFirstWeek(mdfw);
+ res &= true;
+ tRes.tested("setMinimumNumberOfDaysForFirstWeek()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns value that is equal to
+ * value set before. <p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> setMinimumNumberOfDaysForFirstWeek() </code> : sets how
+ * many days of a week must reside in the first week of a year</li>
+ * </ul>
+ */
+ public void _getMinimumNumberOfDaysForFirstWeek() {
+ boolean res = true;
+
+ requiredMethod("setMinimumNumberOfDaysForFirstWeek()");
+ short aShort = oObj.getMinimumNumberOfDaysForFirstWeek();
+ res &= (aShort == mdfw);
+ tRes.tested("getMinimumNumberOfDaysForFirstWeek()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns 12.
+ */
+ public void _getNumberOfMonthsInYear() {
+ boolean res = true;
+ short aShort = oObj.getNumberOfMonthsInYear();
+
+ res &= (aShort == (short) 12);
+ tRes.tested("getNumberOfMonthsInYear()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns 7.
+ */
+ public void _getNumberOfDaysInWeek() {
+ boolean res = true;
+ short aShort = oObj.getNumberOfDaysInWeek();
+
+ res &= (aShort == (short) 7);
+ tRes.tested("getNumberOfDaysInWeek()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if length of array, returned by the method is 12.
+ */
+ public void _getMonths() {
+ boolean res = true;
+ CalendarItem[] months = oObj.getMonths();
+
+ res &= (months.length == 12);
+ tRes.tested("getMonths()", res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if length of array, returned by the method is 7.
+ */
+ public void _getDays() {
+ boolean res = true;
+ CalendarItem[] Days = oObj.getDays();
+
+ res &= (Days.length == 7);
+ tRes.tested("getDays()", res);
+ }
+
+ /**
+ * After loading calendar, test calls the method, then result is checked.<p>
+ * Has <b> OK </b> status if length of string, returned by the method is 3.
+ */
+ public void _getDisplayName() {
+ boolean res = true;
+
+ oObj.loadCalendar(calendars[0][0],installed_locales[0]);
+ String DisplayName = oObj.getDisplayName(CalendarDisplayIndex.MONTH,
+ newValue, (short) 0);
+ res &= (DisplayName.length() == 3);
+ tRes.tested("getDisplayName()", res);
+ }
+
+
+ /**
+ * The test sets obviously wrong value, then calls a method. After that the
+ * test sets correct value, and again calls a method. <p>
+ * Has <b> OK </b> status if the method returns true when valid month is
+ * set, and if the method returns false when set month is not valid.
+ */
+ public void _isValid() {
+ boolean res = true;
+
+ oObj.loadDefaultCalendar(installed_locales[0]);
+ oObj.setValue(CalendarFieldIndex.MONTH, (short) 37);
+ res &= !oObj.isValid();
+ oObj.setValue(CalendarFieldIndex.MONTH, (short) 10);
+ res &= oObj.isValid();
+
+ tRes.tested("isValid()", res);
+ }
+
+}
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java b/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java
new file mode 100644
index 000000000..37d5efb9b
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java
@@ -0,0 +1,398 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.KParseTokens;
+import com.sun.star.i18n.KParseType;
+import com.sun.star.i18n.ParseResult;
+import com.sun.star.i18n.XCharacterClassification;
+import com.sun.star.lang.Locale;
+
+/**
+ * Testing <code>com.sun.star.i18n.XCharacterClassification</code>
+ * interface methods:
+ * <ul>
+ * <li><code> toUpper() </code></li>
+ * <li><code> toLower() </code></li>
+ * <li><code> toTitle() </code></li>
+ * <li><code> getType() </code></li>
+ * <li><code> getCharacterType() </code></li>
+ * <li><code> getStringType() </code></li>
+ * <li><code> getCharacterDirection() </code></li>
+ * <li><code> getScript() </code></li>
+ * <li><code> parseAnyToken() </code></li>
+ * <li><code> parsePredefinedToken() </code></li>
+ * </ul><p>
+ * Test is <b> NOT </b> multithread compliant. <p>
+ * @see com.sun.star.i18n.XCharacterClassification
+ */
+public class _XCharacterClassification extends MultiMethodTest {
+ public XCharacterClassification oObj = null;
+ public String[] languages = new String[]{"de","en","es","fr","ja","ko","zh"};
+ public String[] countries = new String[]{"DE","US","ES","FR","JP","KR","CN"};
+
+ public String[] charstyles_office = new String[] {"UNASSIGNED","UPPERCASE_LETTER",
+ "LOWERCASE_LETTER","TITLECASE_LETTER","MODIFIER_LETTER","OTHER_LETTER",
+ "NON_SPACING_MARK","ENCLOSING_MARK","COMBINING_SPACING_MARK",
+ "DECIMAL_DIGIT_NUMBER","LETTER_NUMBER","OTHER_NUMBER","SPACE_SEPARATOR",
+ "LINE_SEPARATOR","PARAGRAPH_SEPARATOR","CONTROL","FORMAT","PRIVATE_USE",
+ "OTHER_PUNCTUATION","DASH_PUNCTUATION","START_PUNCTUATION","END_PUNCTUATION",
+ "CONNECTOR_PUNCTUATION",
+ "OTHER_PUNCTUATION","MATH_SYMBOL","CURRENCY_SYMBOL","MODIFIER_SYMBOL",
+ "OTHER_SYMBOL","INITIAL_PUNCTUATION","FINAL_PUNCTUATION","GENERAL_TYPES_COUNT"};
+
+ public String[] unicode_script = new String[] {"U_BASIC_LATIN","U_LATIN_1_SUPPLEMENT",
+ "U_LATIN_EXTENDED_A","U_LATIN_EXTENDED_B","U_IPA_EXTENSIONS","U_SPACING_MODIFIER_LETTERS",
+ "U_COMBINING_DIACRITICAL_MARKS","U_GREEK","U_CYRILLIC","U_ARMENIAN","U_HEBREW",
+ "U_ARABIC","U_SYRIAC","U_THAANA","U_DEVANAGARI","U_BENGALI","U_GURMUKHI",
+ "U_GUJARATI","U_ORIYA","U_TAMIL","U_TELUGU","U_KANNADA","U_MALAYALAM",
+ "U_SINHALA","U_THAI","U_LAO","U_TIBETAN","U_MYANMAR","U_GEORGIAN",
+ "U_HANGUL_JAMO","U_ETHIOPIC","U_CHEROKEE","U_UNIFIED_CANADIAN_ABORIGINAL_SYLLABICS",
+ "U_OGHAM","U_RUNIC","U_KHMER","U_MONGOLIAN","U_LATIN_EXTENDED_ADDITIONAL",
+ "U_GREEK_EXTENDED","U_GENERAL_PUNCTUATION","U_SUPERSCRIPTS_AND_SUBSCRIPTS",
+ "U_CURRENCY_SYMBOLS","U_COMBINING_MARKS_FOR_SYMBOLS","U_LETTERLIKE_SYMBOLS",
+ "U_NUMBER_FORMS","U_ARROWS","U_MATHEMATICAL_OPERATORS","U_MISCELLANEOUS_TECHNICAL",
+ "U_CONTROL_PICTURES","U_OPTICAL_CHARACTER_RECOGNITION","U_ENCLOSED_ALPHANUMERICS",
+ "U_BOX_DRAWING","U_BLOCK_ELEMENTS","U_GEOMETRIC_SHAPES","U_MISCELLANEOUS_SYMBOLS",
+ "U_DINGBATS","U_BRAILLE_PATTERNS","U_CJK_RADICALS_SUPPLEMENT","U_KANGXI_RADICALS",
+ "U_IDEOGRAPHIC_DESCRIPTION_CHARACTERS","U_CJK_SYMBOLS_AND_PUNCTUATION",
+ "U_HIRAGANA","U_KATAKANA","U_BOPOMOFO","U_HANGUL_COMPATIBILITY_JAMO","U_KANBUN",
+ "U_BOPOMOFO_EXTENDED","U_ENCLOSED_CJK_LETTERS_AND_MONTHS","U_CJK_COMPATIBILITY",
+ "U_CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A","U_CJK_UNIFIED_IDEOGRAPHS","U_YI_SYLLABLES",
+ "U_YI_RADICALS","U_HANGUL_SYLLABLES","U_HIGH_SURROGATES","U_HIGH_PRIVATE_USE_SURROGATES",
+ "U_LOW_SURROGATES","U_PRIVATE_USE_AREA","U_CJK_COMPATIBILITY_IDEOGRAPHS",
+ "U_ALPHABETIC_PRESENTATION_FORMS","U_ARABIC_PRESENTATION_FORMS_A","U_COMBINING_HALF_MARKS",
+ "U_CJK_COMPATIBILITY_FORMS","U_SMALL_FORM_VARIANTS","U_ARABIC_PRESENTATION_FORMS_B",
+ "U_SPECIALS","U_HALFWIDTH_AND_FULLWIDTH_FORMS","U_CHAR_SCRIPT_COUNT","U_NO_SCRIPT"};
+
+ /**
+ * Test calls the method for different locales. Then each result is compared
+ * with a string, converted to a upper case using
+ * <code>String</code> method <code>toUpperCase()</code>.<p>
+ * Has <b> OK </b> status if string, returned by the method is equal to
+ * a string that is returned by String.toUpperCase() for all locales.
+ */
+ public void _toUpper() {
+ boolean res = true;
+ char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404};
+ String toCheck = new String(characters);
+ String get = "";
+ String exp = "";
+
+ for (int i=0;i<7;i++) {
+ get = oObj.toUpper(toCheck, 0, toCheck.length(), getLocale(i));
+ exp = toCheck.toUpperCase(
+ new java.util.Locale(languages[i], countries[i]));
+ res &= get.equals(exp);
+ if (!res) {
+ log.println("FAILED for: language=" + languages[i] +
+ " ; country=" + countries[i]);
+ log.println("Expected: " + exp);
+ log.println("Gained : " + get);
+ }
+ }
+ tRes.tested("toUpper()", res);
+ }
+
+ /**
+ * Test calls the method for different locales. Then each result is compared
+ * with a string, converted to a lower case using
+ * <code>String</code> method <code>toLowerCase()</code>.<p>
+ * Has <b> OK </b> status if string, returned by the method is equal to
+ * a string that is returned by String.toLowerCase() for all locales.
+ */
+ public void _toLower() {
+ boolean res = true;
+ char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404};
+ String toCheck = new String(characters);
+ String get = "";
+ String exp = "";
+
+ for (int i=0;i<7;i++) {
+ get = oObj.toLower(toCheck,0,toCheck.length(),getLocale(i));
+ exp = toCheck.toLowerCase(
+ new java.util.Locale(languages[i],countries[i]));
+ res &= get.equals(exp);
+ if (!res) {
+ log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ log.println("Expected: " + exp);
+ log.println("Gained : " + get);
+ }
+ }
+ tRes.tested("toLower()", res);
+ }
+
+ /**
+ * Test calls the method for different locales. Then each result is compared
+ * with a string, converted to a title case using
+ * <code>java.lang.Character</code> method <code>toTitleCase()</code>.<p>
+ * Has <b> OK </b> status if string, returned by the method is equal to
+ * a string that was converted using Character.toTitleCase() for all locales.
+ */
+ public void _toTitle() {
+ boolean res = true;
+ String toCheck = new String(new char[]{8112});
+ String get = "";
+ String exp = "";
+
+ for (int i=0;i<7;i++) {
+ get = oObj.toTitle(toCheck, 0, 1, getLocale(i));
+ exp = new String(
+ new char[]{Character.toTitleCase(toCheck.toCharArray()[0])});
+ res &= get.equals(exp);
+ if (!res) {
+ log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ log.println("Expected: " + exp);
+ log.println("Gained : " + get);
+ }
+ }
+ tRes.tested("toTitle()", res);
+ }
+
+ /**
+ * At first we define <code>int[]</code> and <code>char[]</code> arrays of
+ * unicode symbol numbers, arranged as sequences, where symbols are sorted
+ * by type, so the character of <code>i<sup><small>th</small></sup></code>
+ * type is located on <code>i<sup><small>th</small></sup></code> position.<p>
+ * Has <b> OK </b> status if for all 30 types the method returns value, that
+ * is equal to an element number.<p>
+ * @see com.sun.star.i18n.CharType
+ */
+ public void _getType() {
+ boolean res = true;
+ char[] characters = new char[]{586,65,97,498,721,4588,772,8413,3404,
+ 48,8544,179,32,8232,8233,144,8204,57344,56320,173,40,41,95,3852,247,
+ 3647,901,3896,171,187};
+ int[] charsInt = new int[]{586,65,97,498,721,4588,772,8413,3404,48,
+ 8544,179,32,8232,8233,144,8204,57344,56320,173,40,41,95,3852,247,
+ 3647,901,3896,171,187};
+ String toCheck = new String(characters);
+
+ for (int i=0;i<characters.length;i++) {
+ int get = oObj.getType(toCheck, i);
+ res &= charstyles_office[get].equals(charstyles_office[i]);
+ if (!res) {
+ log.println("Code :" + Integer.toHexString(charsInt[i]));
+ log.println("Gained: " + charstyles_office[get]);
+ log.println("Expected : " + charstyles_office[i]);
+ }
+ }
+ tRes.tested("getType()", res);
+ }
+
+ /**
+ * After defining string to be checked and array of expected types, test
+ * calls the method for each character of a string and for all locales.<p>
+ * Has <b> OK </b> status if the method returns type, expected for a given
+ * character and locale.
+ */
+ public void _getCharacterType() {
+ boolean res = true;
+ String toCheck = "Ab0)";
+ int[] expected = new int[]{226,228,97,32};
+
+ for (int i=0;i<toCheck.length();i++) {
+ for (int j=1;j<7;j++) {
+ int get = oObj.getCharacterType(toCheck, i, getLocale(j));
+ res &= (get == expected[i]);
+ if (!res) {
+ log.println("FAILED for: language=" + languages[j] +
+ " ; country=" + countries[j]);
+ log.println("Symbol :" + toCheck.toCharArray()[i]);
+ log.println("Gained: " + get);
+ log.println("Expected : " + expected[i]);
+ }
+ }
+ }
+ tRes.tested("getCharacterType()", res);
+ }
+
+ /**
+ * After defining array of strings to be checked and array of expected types,
+ * test calls the method for each string of an array and for all locales.<p>
+ * Has <b> OK </b> status if the method returns type, expected for a given
+ * string and locale.
+ */
+ public void _getStringType() {
+ boolean res = true;
+ String[] toCheck = new String[]{"01234","AAAAA","bbbbb","AA()bb"};
+ int[] exp = new int[]{97,226,228,230};
+
+ for (int j=0;j<toCheck.length;j++) {
+ for (int i=0;i<7;i++) {
+ int get = oObj.getStringType(toCheck[j], 0,
+ toCheck[j].length(), getLocale(i));
+ res &= (get == exp[j]);
+ if (!res) {
+ log.println("FAILED for: language=" + languages[i] +
+ " ; country=" + countries[i]);
+ log.println("Expected: " + exp[j]);
+ log.println("Gained : " + get);
+ }
+ }
+ }
+ tRes.tested("getStringType()", res);
+ }
+
+ /**
+ * After string to be checked is initialized (all symbols are sorted
+ * by direction, so the character of <code>i<sup><small>th</small></sup></code>
+ * direction is located on <code>i<sup><small>th</small></sup></code>
+ * position), test calls the method for every character of that string. <p>
+ * Has <b> OK </b> status if the method returns direction, that's equal to
+ * a symbol position in the string.
+ */
+ public void _getCharacterDirection() {
+ boolean res = true;
+ String toCheck = new String(new char[]{65,1470,48,47,35,1632,44,10,
+ 9,12,33,8234,8237,1563,8235,8238,8236,768,1});
+ for (short i=0;i<19;i++) {
+ short get = oObj.getCharacterDirection(toCheck, i);
+ res &= (get == i);
+ if (!res) {
+ log.println("Code :" + toCheck.toCharArray()[i]);
+ log.println("Gained: " + get);
+ log.println("Expected: " + i);
+ }
+ }
+ tRes.tested("getCharacterDirection()", res);
+ }
+
+ /**
+ * At first we define <code>int[]</code> and <code>char[]</code> arrays of
+ * unicode symbol numbers, arranged as sequences, where symbols are sorted
+ * by type, so the character of <code>i<sup><small>th</small></sup></code>
+ * type is located on <code>i<sup><small>th</small></sup></code> position.<p>
+ * Has <b> OK </b> status if for each character method returns value, that
+ * is equal to a number where element is located in array. Also method has
+ * <b> OK </b> status for symbol with code 55296, because it doesn't work
+ * since it hasn't the right neighborhood.<p>
+ * @see "http://ppewww.ph.gla.ac.uk/~flavell/unicode/unidata.html"
+ */
+ public void _getScript() {
+ boolean res = true;
+ char[] characters = new char[]{65,128,256,384,592,750,773,924,1030,1331,1448,
+ 1569,1792,1936,2313,2465,2570,2707,2822,2972,3079,3240,3337,3464,3590,
+ 3745,3906,4097,4274,4357,4621,5040,5200,5776,5806,6030,6155,7683,7943,
+ 8202,8319,8352,8413,8452,8545,8616,8715,8965,9217,9281,9336,9474,9608,9719,
+ 9734,9999,10247,11911,12034,12274,12294,12358,12456,12552,12605,12688,12727,
+ 12806,13065,13312,19968,40964,42152,44032,55296,56192,56320,57344,63744,
+ 64257,64370,65056,65073,65131,65146,65532,65288};
+ int[] charsInt = new int[]{65,128,256,384,592,750,773,924,1030,1331,1448,
+ 1569,1792,1936,2313,2465,2570,2707,2822,2972,3079,3240,3337,3464,3590,
+ 3745,3906,4097,4274,4357,4621,5040,5200,5776,5806,6030,6155,7683,7943,
+ 8202,8319,8352,8413,8452,8545,8616,8715,8965,9217,9281,9336,9474,9608,9719,
+ 9734,9999,10247,11911,12034,12274,12294,12358,12456,12552,12605,12688,12727,
+ 12806,13065,13312,19968,40964,42152,44032,55296,56192,56320,57344,63744,
+ 64257,64370,65056,65073,65131,65146,65532,65288};
+ String toCheck = new String(characters);
+
+ for (int i=0;i<characters.length;i++) {
+ int get = oObj.getScript(toCheck, i);
+ res &= (get == i);
+ //The HIGH_SURROGATE 55296 doesn't work since it hasn't the right
+ //neighborhood
+ if (toCheck.substring(i, i + 1).hashCode() == 55296) res = true;
+ if (!res) {
+ log.println("-- " + toCheck.substring(i, i + 1).hashCode());
+ log.println("Code: " + Integer.toHexString(charsInt[i]));
+ log.println("Gained: " + unicode_script[get]);
+ log.println("Expected: " + unicode_script[i]);
+ }
+ }
+ tRes.tested("getScript()", res);
+ }
+
+ /**
+ * After defining a string to be parsed and parse conditions (flags), test
+ * calls the method for different locales three times with different parameters,
+ * checking result after every call. <p>
+ * Has <b> OK </b> status if the method returns right results all three
+ * times.
+ */
+ public void _parseAnyToken() {
+ int nStartFlags = KParseTokens.ANY_ALPHA | KParseTokens.ASC_UNDERSCORE;
+ int nContFlags = KParseTokens.ANY_ALNUM | KParseTokens.ASC_UNDERSCORE
+ | KParseTokens.ASC_DOT;
+ String toCheck = " 18 i18n ^";
+ ParseResult pRes = null;
+ boolean res = true;
+
+ for (int i=0;i<7;i++) {
+ pRes = oObj.parseAnyToken(toCheck, 1, getLocale(i),
+ nStartFlags, "", nContFlags, "");
+ res = ( (pRes.CharLen==2)
+ && (pRes.TokenType==32)
+ && (pRes.Value==18.0) );
+ pRes = oObj.parseAnyToken(toCheck, 4, getLocale(i),
+ nStartFlags, "", nContFlags, "");
+ res &= ( (pRes.CharLen==4)
+ && (pRes.TokenType==4)
+ && (pRes.Value==0.0) );
+ pRes = oObj.parseAnyToken(toCheck, 9, getLocale(i),
+ nStartFlags, "", nContFlags, "");
+ res &= ( (pRes.CharLen==1)
+ && (pRes.TokenType==1)
+ && (pRes.Value==0.0) );
+ }
+ tRes.tested("parseAnyToken()", res);
+ }
+
+ /**
+ * After defining a string to be parsed and parse conditions (flags), test
+ * calls the method for different locales two times with different parameters,
+ * checking result after every call. <p>
+ * Has <b> OK </b> status if the method returns right results.
+ */
+ public void _parsePredefinedToken() {
+ int nStartFlags = KParseTokens.ANY_ALPHA | KParseTokens.ASC_UNDERSCORE;
+ int nContFlags = nStartFlags;
+ String toCheck = " 18 int";
+ ParseResult pRes = null;
+ boolean res = true;
+
+ for (int i=0;i<7;i++) {
+ pRes = oObj.parsePredefinedToken(KParseType.IDENTNAME, toCheck,
+ 1, getLocale(i), nStartFlags, "", nContFlags, "");
+ res = (pRes.CharLen==0);
+ pRes = oObj.parsePredefinedToken(KParseType.IDENTNAME, toCheck,
+ 4, getLocale(i), nStartFlags, "", nContFlags, "");
+ res &= ( (pRes.CharLen==3)
+ && (pRes.TokenType==4)
+ && (pRes.Value==0.0) );
+ }
+ tRes.tested("parsePredefinedToken()", res);
+ }
+
+
+ /**
+ * Method returns locale for a given language and country.
+ * @param k index of needed locale.
+ */
+ private Locale getLocale(int k) {
+ return new Locale(languages[k],countries[k],"");
+ }
+
+
+} // end XCharacterClassification
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XCollator.java b/qadevOOo/tests/java/ifc/i18n/_XCollator.java
new file mode 100644
index 000000000..a9eece7f7
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XCollator.java
@@ -0,0 +1,422 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import java.text.Collator;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.CollatorOptions;
+import com.sun.star.i18n.XCollator;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XCollator</code>
+* interface methods :
+* <ul>
+* <li><code> compareSubstring()</code></li>
+* <li><code> compareString()</code></li>
+* <li><code> loadDefaultCollator()</code></li>
+* <li><code> loadCollatorAlgorithm()</code></li>
+* <li><code> listCollatorAlgorithms()</code></li>
+* <li><code> loadCollatorAlgorithmWithEndUserOption()</code></li>
+* <li><code> listCollatorOptions()</code></li>
+* </ul> <p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XCollator
+*/
+public class _XCollator extends MultiMethodTest {
+ public XCollator oObj = null;
+ private String[] alg = null ;
+ Locale loc = new Locale("en", "EN", "");
+
+ /**
+ * Just retrieves a list of algorithms. <p>
+ * Has <b>OK</b> status if non-zero length array returned.
+ */
+ public void _listCollatorAlgorithms() {
+ alg = oObj.listCollatorAlgorithms(loc) ;
+ log.println("Collator algorithms :");
+ if (alg != null) {
+ for (int i = 0; i < alg.length; i++) {
+ log.println(" '" + alg[i] + "'") ;
+ }
+ tRes.tested("listCollatorAlgorithms()", alg.length > 0) ;
+ } else {
+ tRes.tested("listCollatorAlgorithms()", false) ;
+ }
+ }
+
+ /**
+ * Just gets a list of options for some collator. <p>
+ * Has <b>OK</b> status if not null value returned.<p>
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> listCollatorAlgorithms </code> : to have some
+ * algorithm name. </li>
+ * </ul>
+ */
+ public void _listCollatorOptions() {
+ requiredMethod("listCollatorAlgorithms()") ;
+ int[] opt = oObj.listCollatorOptions(alg[0]) ;
+ log.println("Collator '" + alg[0] + "' options :");
+ if (opt != null) {
+ for (int i = 0; i < opt.length; i++) {
+ log.println(" " + opt[i]) ;
+ }
+ tRes.tested("listCollatorOptions()", true) ;
+ } else {
+ tRes.tested("listCollatorOptions()", false) ;
+ }
+ }
+
+ /**
+ * Calls the method with no options and with options(IGNORE_CASE),
+ * compares strings.<p>
+ * Has <b>OK</b> status if compareString() returned correct values.
+ */
+ public void _loadDefaultCollator() {
+ oObj.loadDefaultCollator(loc, 0);
+ boolean res = oObj.compareString("A", "a") != 0;
+ oObj.loadDefaultCollator(loc,
+ CollatorOptions.CollatorOptions_IGNORE_CASE);
+ res &= oObj.compareString("a", "A") == 0;
+ tRes.tested("loadDefaultCollator()", res) ;
+ }
+
+ /**
+ * Calls the method with no options and with options(IGNORE_CASE),
+ * compares strings.<p>
+ * Has <b>OK</b> status if compareString() returned correct values.
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> listCollatorAlgorithms </code> : to have some
+ * algorithm name. </li>
+ * </ul>
+ */
+ public void _loadCollatorAlgorithm() {
+ requiredMethod("listCollatorAlgorithms()");
+ oObj.loadCollatorAlgorithm(alg[0], loc,
+ CollatorOptions.CollatorOptions_IGNORE_CASE);
+ boolean res = oObj.compareString("A", "a") == 0;
+ oObj.loadCollatorAlgorithm(alg[0], loc, 0);
+ res &= oObj.compareString("a", "A") != 0;
+ tRes.tested("loadCollatorAlgorithm()", res);
+ }
+
+ /**
+ * Calls the method with no options and with options(IGNORE_CASE),
+ * compares strings.<p>
+ * Has <b>OK</b> status if compareString() returned correct values.
+ * The following method tests are to be completed successfully before :
+ * <ul>
+ * <li> <code> listCollatorAlgorithms </code> : to have some
+ * algorithm name. </li>
+ * </ul>
+ */
+ public void _loadCollatorAlgorithmWithEndUserOption() {
+ requiredMethod("listCollatorAlgorithms()");
+ oObj.loadCollatorAlgorithmWithEndUserOption(alg[0], loc,
+ new int[] {0});
+ boolean res = oObj.compareString("A", "a") != 0;
+ oObj.loadCollatorAlgorithmWithEndUserOption(alg[0], loc,
+ new int[] {CollatorOptions.CollatorOptions_IGNORE_CASE});
+ res = oObj.compareString("A", "a") == 0;
+ tRes.tested("loadCollatorAlgorithmWithEndUserOption()", res);
+ }
+
+ /**
+ * Test is performed for locales : en, ru, ja, zh, ko.
+ * Default collator is loaded for each locale. Then collation
+ * is performed for different combination of symbols from range of
+ * this locale.<p>
+ * Has <b>OK</b> status if comparing of different strings
+ * returns not 0 value, then comparing in the opposite
+ * order returns value with opposite sign, and comparing
+ * of two equal strings returns 0. The such comparing is performed
+ * for one character strings.
+ */
+ public void _compareSubstring() {
+ boolean result = true ;
+ char[] chars = new char[2] ;
+ Collator col = null ;
+
+ log.println(" #### Testing English locale ####") ;
+ oObj.loadDefaultCollator(loc, 0) ;
+ col = Collator.getInstance(new java.util.Locale("en", "EN")) ;
+ for (char ch = 0x0020; ch < 0x007F; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareSubstring(chars, col) ;
+ }
+
+ log.println(" #### Testing Russian locale ####") ;
+ oObj.loadDefaultCollator(
+ new com.sun.star.lang.Locale("ru", "RU", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ru", "RU")) ;
+ for (char ch = 0x0410; ch < 0x0450; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareSubstring(chars, col) ;
+ }
+
+ log.println(" #### Testing Japan locale ####") ;
+ oObj.loadDefaultCollator(
+ new com.sun.star.lang.Locale("ja", "JP", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ja", "JP")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareSubstring(chars, col) ;
+ }
+
+ log.println(" #### Testing China locale ####") ;
+ oObj.loadDefaultCollator(new Locale("zh", "CN", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("zh", "CN")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareSubstring(chars, col) ;
+ }
+
+ log.println(" #### Testing Korean locale ####") ;
+ oObj.loadDefaultCollator(new Locale("ko", "KR", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ko", "KR")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareSubstring(chars, col) ;
+ }
+
+ tRes.tested("compareSubstring()", result) ;
+ }
+
+ /**
+ * Test is performed for locales : en, ru, ja, zh, ko.
+ * Default collator is loaded for each locale. Then collation
+ * is performed for different combination of symbols from range of
+ * this locale.<p>
+ * Has <b>OK</b> status if comparing of different strings
+ * returns not 0 value, then comparing in the opposite
+ * order returns value with opposite sign, and comparing
+ * of two equal strings returns 0. The such comparing is performed
+ * for one character strings.
+ */
+ public void _compareString() {
+ boolean result = true ;
+ char[] chars = new char[2] ;
+ Collator col = null ;
+ log.println(" #### Testing English locale ####") ;
+ oObj.loadDefaultCollator(
+ new com.sun.star.lang.Locale("en", "EN", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("en", "EN")) ;
+ for (char ch = 0x0020; ch < 0x007F; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareString(chars, col) ;
+ }
+
+ log.println(" #### Testing Russian locale ####") ;
+ oObj.loadDefaultCollator(
+ new com.sun.star.lang.Locale("ru", "RU", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ru", "RU")) ;
+ for (char ch = 0x0410; ch < 0x0450; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareString(chars, col) ;
+ }
+
+ log.println(" #### Testing Japan locale ####") ;
+ oObj.loadDefaultCollator(
+ new com.sun.star.lang.Locale("ja", "JP", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ja", "JP")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareString(chars, col) ;
+ }
+
+ log.println(" #### Testing China locale ####") ;
+ oObj.loadDefaultCollator(new Locale("zh", "CN", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("zh", "CN")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareString(chars, col) ;
+ }
+
+ log.println(" #### Testing Korean locale ####") ;
+ oObj.loadDefaultCollator(new Locale("ko", "KR", ""), 0) ;
+ col = Collator.getInstance(new java.util.Locale("ko", "KR")) ;
+ for (char ch = 0x4E00; ch < 0x4EFD; ch ++) {
+ chars[0] = ch ; chars[1] = (char) (ch + 1) ;
+ result &= testCompareString(chars, col) ;
+ }
+
+ tRes.tested("compareString()", result) ;
+ }
+
+
+ /**
+ * Testing compareString() method. At first method is testing single chars
+ * comparing, then strings comparing.
+ * @param locChar sequence of at list two characters of a given locale
+ * to be used in comparing.
+ * @param col Collator for a given locale
+ * @return true if:
+ * <ol>
+ * <li> if comparing of two identical characters returns zero</li>
+ * <li> if comparing of two different characters returns non zero</li>
+ * <li> if comparing of two identical strings, composed of given chars
+ * returns zero</li>
+ * <li> if comparing of two different strings, composed of given chars
+ * returns non zero</li>
+ * </ol>
+ */
+ public boolean testCompareString(char[] locChar, Collator col) {
+ boolean result = true;
+ int res;
+ String msg = "";
+
+ String char0 = "_"+new String(new char[] {locChar[0]});
+ String char1 = "_"+new String(new char[] {locChar[1]});
+ res = oObj.compareString(char0 , char0) ;
+ if (res != 0) {
+ msg += " Testing collation of single equal characters ("
+ + toUnicode(char0) + ") ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ res = oObj.compareString(char0, char1) ;
+ if (res == 0) {
+ msg += " Testing collation of single different" +
+ " characters (" + toUnicode(char0+char1) +
+ ") ... FAILED (0 returned)\n" ;
+ msg += " Java collator returned " +
+ col.compare(char0, char1) + "\n" ;
+ result = false ;
+ } else { // opposite order - sum of results must be 0
+ res += oObj.compareString(char1, char0) ;
+ if (res != 0) {
+ msg += " Testing collation of single different" +
+ " characters (" + toUnicode(char0+char1) +
+ ") ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ }
+
+ String str1 = new String(new char[] {locChar[0], locChar[0],
+ locChar[1], locChar[1], locChar[1]}) ;
+ String str2 = new String(new char[] {locChar[0], locChar[0],
+ locChar[0], locChar[1], locChar[1]}) ;
+
+ res = oObj.compareString(str1 , str1) ;
+ if (res != 0) {
+ msg += " Testing collation of equal strings (" +
+ toUnicode(str1) + ") ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ res = oObj.compareString(str1, str2) ;
+ if (res == 0) {
+ msg += " Testing collation of different strings ((" +
+ toUnicode(str1) + "),(" + toUnicode(str2) +
+ ")) ... FAILED (0 returned)\n" ;
+ msg += " Java collator returned " +
+ col.compare(str1, str2) + "\n" ;
+ result = false ;
+ } else { // opposite order - sum of results must be
+ res += oObj.compareString(str2, str1) ;
+ if (res != 0) {
+ msg += " Testing collation of different strings ((" +
+ toUnicode(str1) + "),(" + toUnicode(str2) +
+ ")) ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ }
+
+ if (!result) {
+ log.println(msg) ;
+ }
+ return result ;
+ }
+
+
+ /**
+ * Testing compareSubstring() method. Method is testing substrings comparing.
+ * @param locChar sequence of at list two characters of a given locale
+ * to be used in comparing.
+ * @param col Collator for a given locale
+ * @return true if:
+ * <ol>
+ * <li> if comparing of two identical substrings of strings, composed
+ * of given chars returns zero</li>
+ * <li> if comparing of two different substrings of strings, composed
+ * of given chars returns non zero</li>
+ * </ol>
+ */
+ public boolean testCompareSubstring(char[] locChar, Collator col) {
+ boolean result = true ;
+ int res ;
+ String msg = "" ;
+
+ String str1 = new String(new char[] {locChar[0], locChar[0],
+ locChar[1], locChar[1], locChar[1]}) ;
+ String str2 = new String(new char[] {locChar[0], locChar[0],
+ locChar[0], locChar[1], locChar[1]}) ;
+
+ res = oObj.compareSubstring(str1, 1, 2 , str2, 2, 2) ;
+ if (res != 0) {
+ msg += " Testing collation of equal substrings (" +
+ toUnicode(str1) + ") ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ res = oObj.compareSubstring(str1, 1, 2, str2, 1, 2) ;
+ if (res == 0) {
+ msg += " Testing collation of different strings ((" +
+ toUnicode(str1.substring(1, 3)) + "),(" +
+ toUnicode(str2.substring(1, 3))
+ + ")) ... FAILED (0 returned)\n" ;
+ msg += " Java collator returned " + col.compare
+ (str1.substring(1, 3), str2.substring(1, 3)) + "\n" ;
+ result = false ;
+ } else { // opposite order - sum of results must be
+ res += oObj.compareSubstring(str2, 1, 2, str1, 1, 2) ;
+ if (res != 0) {
+ msg += " Testing collation of different strings ((" +
+ toUnicode(str1) + "),(" + toUnicode(str2) +
+ ")) ... FAILED\n" ;
+ }
+ result &= res == 0 ;
+ }
+
+ if (!result) {
+ log.println(msg) ;
+ }
+ return result ;
+ }
+
+
+ /**
+ * Transforms string to unicode hex codes.
+ * @param str String to be transformed
+ */
+ public String toUnicode(String str) {
+ char[] chars = str.toCharArray() ;
+ StringBuilder res = new StringBuilder();
+ for (int i = 0; i < chars.length; i++) {
+ if (i != 0) {
+ res.append(",");
+ }
+ res.append(Integer.toHexString(chars[i]));
+ }
+ return res.toString();
+ }
+
+}
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java b/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java
new file mode 100644
index 000000000..bd190241c
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java
@@ -0,0 +1,125 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+package ifc.i18n;
+
+import com.sun.star.i18n.CalendarDisplayCode;
+import com.sun.star.i18n.NativeNumberMode;
+import com.sun.star.i18n.XExtendedCalendar;
+import com.sun.star.i18n.XLocaleData;
+import com.sun.star.lang.Locale;
+import com.sun.star.uno.UnoRuntime;
+import java.text.SimpleDateFormat;
+import java.util.Calendar;
+import java.util.Date;
+import java.util.GregorianCalendar;
+import lib.MultiMethodTest;
+
+/**
+ *
+ */
+public class _XExtendedCalendar extends MultiMethodTest {
+ public XExtendedCalendar oObj = null;
+ boolean useUSENLocale = false;
+ /**
+ * Load a calendar
+ */
+ @Override
+ public void before() throws Exception {
+ Locale[] installed_locales = null;
+ XLocaleData locData = UnoRuntime.queryInterface(
+ XLocaleData.class,
+ tParam.getMSF().createInstance(
+ "com.sun.star.i18n.LocaleData"));
+
+ installed_locales = locData.getAllInstalledLocaleNames();
+ // use first Locale as fallback, if US-English is not found
+ Locale lo = installed_locales[0];
+ for (int i=0; i<installed_locales.length; i++) {
+ // search for "en" and "US"
+ if (installed_locales[i].Language.equals("en") &&
+ installed_locales[i].Country.equals("US")) {
+ lo = installed_locales[i];
+ useUSENLocale = true;
+ }
+ }
+ log.println("Choose Locale: '" + lo.Language + "', '" + lo.Country + "'");
+ oObj.loadDefaultCalendar(lo);
+ }
+
+
+ public void _getDisplayString() {
+ // against regression: the current state is the right one.
+ boolean result = true;
+ String[] displayString = new String[6];
+ // build the defaults with the Java Calendar functions
+ String[] expectedStringResult = new String[6];
+ Calendar cal = new GregorianCalendar();
+ Date actualDate = cal.getTime();
+
+ SimpleDateFormat sdf = getSDF("yy");
+ expectedStringResult[0] = "AD" + sdf.format(actualDate);
+
+ sdf = getSDF("yyyy");
+ expectedStringResult[1] = "AD" + sdf.format(actualDate);
+
+ sdf = getSDF("MM");
+ expectedStringResult[2] = sdf.format(actualDate);
+
+ int month = cal.get(Calendar.MONTH) + 1;
+ String quarter = "Q1";
+ String longQuarter = "1st quarter";
+ if (month > 3 && month < 7) { quarter = "Q2"; longQuarter = "2nd quarter"; }
+ else if (month > 6 && month < 10) { quarter = "Q3"; longQuarter = "3rd quarter"; }
+ else if (month > 10 && month < 13) {quarter = "Q4"; longQuarter = "4th quarter"; }
+ expectedStringResult[3] = quarter;
+ expectedStringResult[4] = longQuarter;
+
+ sdf = getSDF("MMMM");
+ expectedStringResult[5] = sdf.format(actualDate);
+
+ displayString[0] = oObj.getDisplayString(CalendarDisplayCode.SHORT_YEAR_AND_ERA, NativeNumberMode.NATNUM0);
+ displayString[1] = oObj.getDisplayString(CalendarDisplayCode.LONG_YEAR_AND_ERA, NativeNumberMode.NATNUM0);
+ displayString[2] = oObj.getDisplayString(CalendarDisplayCode.LONG_MONTH, NativeNumberMode.NATNUM0);
+ displayString[3] = oObj.getDisplayString(CalendarDisplayCode.SHORT_QUARTER, NativeNumberMode.NATNUM0);
+ displayString[4] = oObj.getDisplayString(CalendarDisplayCode.LONG_QUARTER, NativeNumberMode.NATNUM0);
+ displayString[5] = oObj.getDisplayString(CalendarDisplayCode.LONG_MONTH_NAME, NativeNumberMode.NATNUM0);
+
+ for (int i=0; i<displayString.length; i++) {
+ boolean locResult = false;
+ if (useUSENLocale) {
+ locResult = displayString[i].equals(expectedStringResult[i]);
+ if (!locResult)
+ log.println("getDisplayString() result " + i + ": '" + displayString[i]
+ + "', expected: '" + expectedStringResult[i] + "'");
+ result &= locResult;
+ }
+ else { // no defaults for other locales, just expect a String
+ locResult &= displayString[i] != null;
+ if (!locResult)
+ log.println("getDisplayString() result " + i + " was 'null'");
+ result &= locResult;
+ }
+ }
+ tRes.tested("getDisplayString()", result);
+ }
+
+ private SimpleDateFormat getSDF(String format){
+ if (useUSENLocale) return new SimpleDateFormat(format, java.util.Locale.US);
+ return new SimpleDateFormat(format);
+ }
+}
diff --git a/qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java b/qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java
new file mode 100644
index 000000000..7793a8cdd
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java
@@ -0,0 +1,311 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+package ifc.i18n;
+
+import com.sun.star.i18n.CollatorOptions;
+import com.sun.star.i18n.XExtendedIndexEntrySupplier;
+import com.sun.star.lang.Locale;
+
+import java.util.HashMap;
+
+import lib.MultiMethodTest;
+
+
+public class _XExtendedIndexEntrySupplier extends MultiMethodTest {
+ public XExtendedIndexEntrySupplier oObj;
+ protected Locale[] locales = null;
+ protected HashMap<Integer, String[]> algorithms = new HashMap<Integer, String[]>();
+
+ public void _compareIndexEntry() {
+ requiredMethod("getIndexKey()");
+ Locale locale = new Locale("zh", "CN", "");
+ String val1 = new String(new char[]{UnicodeStringPair.getUnicodeValue(0), UnicodeStringPair.getUnicodeValue(1)});
+ String val2 = new String(new char[]{UnicodeStringPair.getUnicodeValue(1), UnicodeStringPair.getUnicodeValue(0)});
+ short result1 = oObj.compareIndexEntry(val1, "", locale, val1, "", locale);
+ short result2 = oObj.compareIndexEntry(val1, "", locale, val2, "", locale);
+ short result3 = oObj.compareIndexEntry(val2, "", locale, val1, "", locale);
+
+ tRes.tested("compareIndexEntry()", result1 == 0 && result2 + result3 == 0);
+ }
+
+ /*
+ * gets the list of all algorithms for each listed language
+ * is OK if everyone of the returned lists are filled
+ */
+ public void _getAlgorithmList() {
+ requiredMethod("getLocaleList()");
+
+ boolean result = true;
+
+ for (int i = 0; i < locales.length; i++) {
+ String[] algNames = oObj.getAlgorithmList(locales[i]);
+ algorithms.put(Integer.valueOf(i), algNames);
+
+ boolean locResult = algNames.length > 0;
+ System.out.println("Locale " + i + ": " + locales[i].Country+","+locales[i].Language);
+
+ for (int j=0; j<algNames.length; j++) {
+ System.out.println("\tAlgorithm " + j + ": " + algNames[j]);
+ }
+
+ if (!locResult) {
+ log.println("No Algorithm found for " + locales[i].Country +
+ "," + locales[i].Language);
+ }
+
+ result &= locResult;
+ }
+
+ tRes.tested("getAlgorithmList()", result);
+ }
+
+ public void _getIndexKey() {
+ requiredMethod("loadAlgorithm()");
+ char[] characters = new char[] { 19968 };
+ String getIndexFor = new String(characters);
+ for (int i = 0; i < locales.length; i++) {
+ log.println("Language: " + locales[i].Language);
+
+ for (int j = 0; j < algorithms.size(); j++) {
+ String[] algs = algorithms.get(Integer.valueOf(j));
+ for (int k=0;k<algs.length;k++) {
+ log.println("\t Algorithm :" +
+ algs[k]);
+ oObj.loadAlgorithm(locales[i], algs[k], CollatorOptions.CollatorOptions_IGNORE_CASE);
+ log.println("\t\t Get: " +
+ oObj.getIndexKey(getIndexFor, "", locales[i]));
+ }
+ }
+ }
+ tRes.tested("getIndexKey()", true);
+ }
+
+ /*
+ * gets a list of all locales, is OK if this list isn't empty
+ */
+ public void _getLocaleList() {
+ locales = oObj.getLocaleList();
+ tRes.tested("getLocaleList()", locales.length > 0);
+ }
+
+ /*
+ * gets one phonetic candidate for the chinese local
+ * is ok if 'yi' is returned as expected.
+ */
+ public void _getPhoneticCandidate() {
+ requiredMethod("getLocaleList()");
+
+ boolean res = true;
+
+ Locale loc = new Locale("zh", "CN", "");
+
+ for (int i = 0;i<UnicodeStringPair.getValCount();i++) {
+
+ char[] c = new char[]{UnicodeStringPair.getUnicodeValue(i)};
+
+ String getting = oObj.getPhoneticCandidate(new String(c), loc);
+
+ boolean locResult = getting.equals(UnicodeStringPair.getExpectedPhoneticString(i));
+
+ if (!locResult) {
+ log.println("Char: "+ c[0] + " (" + (int)c[0] + ")");
+ log.println("Expected " + UnicodeStringPair.getExpectedPhoneticString(i));
+ log.println("Getting " + getting);
+ }
+
+ res &= locResult;
+ }
+ tRes.tested("getPhoneticCandidate()", res);
+ }
+
+ /*
+ * loads all algorithms available in all language.
+ * Is OK if no exception occurs and the method returns
+ * true for each valid algorithm and false otherwise
+ */
+ public void _loadAlgorithm() {
+ requiredMethod("getAlgorithmList()");
+
+ boolean res = true;
+
+ for (int i = 0; i < algorithms.size(); i++) {
+ String[] names = algorithms.get(Integer.valueOf(i));
+ log.println("loading algorithms for " + locales[i].Country +
+ "," + locales[i].Language);
+
+ for (int j = 0; j < names.length; j++) {
+ log.println("\t Loading " + names[j]);
+
+ boolean localres = oObj.loadAlgorithm(locales[i], names[j],
+ CollatorOptions.CollatorOptions_IGNORE_CASE);
+
+ if (!localres) {
+ log.println("\t ... didn't work - FAILED");
+ } else {
+ log.println("\t ... worked - OK");
+ }
+
+ res &= localres;
+ }
+ }
+
+ tRes.tested("loadAlgorithm()", res);
+ }
+
+ /*
+ * checks the method usePhoneticEntry(). Only the languages ja, ko and zh
+ * should return true. Has OK state if exactly this is the case.
+ */
+ public void _usePhoneticEntry() {
+ requiredMethod("getLocaleList()");
+
+ boolean res = true;
+
+ for (int i = 0; i < locales.length; i++) {
+ boolean expected = false;
+
+ if (locales[i].Language.equals("ja") ||
+ locales[i].Language.equals("ko") ||
+ locales[i].Language.equals("zh")) {
+ expected = true;
+ }
+
+ boolean locResult = oObj.usePhoneticEntry(locales[i]) == expected;
+
+ if (!locResult) {
+ log.println("Failure for language " + locales[i].Language);
+ log.println("Expected " + expected);
+ log.println("Getting " + oObj.usePhoneticEntry(locales[i]));
+ }
+
+ res &= locResult;
+ }
+
+ tRes.tested("usePhoneticEntry()", res);
+ }
+
+ /**
+ * Helper class to handle the phonetic equivalence of unicode characters
+ * This class delivers an amount of unicode characters and the equivalent phonetics
+ * for the "getPhoneticCandidate" test. Equivalents are only usable for zh,CN locale.
+ */
+ public static class UnicodeStringPair {
+ static final int valCount = 78;
+ static final String[] sStringEquivalence = new String[valCount];
+ static final char[] iUnicodeEquivalence = new char[valCount];
+
+ static {
+ fillValues();
+ }
+
+ public static int getValCount() {
+ return valCount;
+ }
+
+ public static String getExpectedPhoneticString(int index) {
+ if (index >= valCount) return null;
+ return sStringEquivalence[index];
+ }
+
+ public static char getUnicodeValue(int index) {
+ if (index > valCount) return 0;
+ return iUnicodeEquivalence[index];
+ }
+
+ private static void fillValues() {
+ iUnicodeEquivalence[0] = 20049; sStringEquivalence[0] = "zhong";
+ iUnicodeEquivalence[1] = 19968; sStringEquivalence[1] = "yi";
+ iUnicodeEquivalence[2] = 19969; sStringEquivalence[2] = "ding";
+ iUnicodeEquivalence[3] = 19970; sStringEquivalence[3] = "kao";
+ iUnicodeEquivalence[4] = 19971; sStringEquivalence[4] = "qi";
+ iUnicodeEquivalence[5] = 19972; sStringEquivalence[5] = "shang";
+ iUnicodeEquivalence[6] = 19973; sStringEquivalence[6] = "xia";
+ iUnicodeEquivalence[7] = 19975; sStringEquivalence[7] = "wan";
+ iUnicodeEquivalence[8] = 19976; sStringEquivalence[8] = "zhang";
+ iUnicodeEquivalence[9] = 19977; sStringEquivalence[9] = "san";
+ iUnicodeEquivalence[10] = 19978; sStringEquivalence[10] = "shang";
+ iUnicodeEquivalence[11] = 19979; sStringEquivalence[11] = "xia";
+ iUnicodeEquivalence[12] = 19980; sStringEquivalence[12] = "ji";
+ iUnicodeEquivalence[13] = 19981; sStringEquivalence[13] = "bu";
+ iUnicodeEquivalence[14] = 19982; sStringEquivalence[14] = "yu";
+ iUnicodeEquivalence[15] = 19983; sStringEquivalence[15] = "mian";
+ iUnicodeEquivalence[16] = 19984; sStringEquivalence[16] = "gai";
+ iUnicodeEquivalence[17] = 19985; sStringEquivalence[17] = "chou";
+ iUnicodeEquivalence[18] = 19986; sStringEquivalence[18] = "chou";
+ iUnicodeEquivalence[19] = 19987; sStringEquivalence[19] = "zhuan";
+ iUnicodeEquivalence[20] = 19988; sStringEquivalence[20] = "qie";
+ iUnicodeEquivalence[21] = 19989; sStringEquivalence[21] = "pi";
+ iUnicodeEquivalence[22] = 19990; sStringEquivalence[22] = "shi";
+ iUnicodeEquivalence[23] = 19991; sStringEquivalence[23] = "shi";
+ iUnicodeEquivalence[24] = 19992; sStringEquivalence[24] = "qiu";
+ iUnicodeEquivalence[25] = 19993; sStringEquivalence[25] = "bing";
+ iUnicodeEquivalence[26] = 19994; sStringEquivalence[26] = "ye";
+ iUnicodeEquivalence[27] = 19995; sStringEquivalence[27] = "cong";
+ iUnicodeEquivalence[28] = 19996; sStringEquivalence[28] = "dong";
+ iUnicodeEquivalence[29] = 19997; sStringEquivalence[29] = "si";
+ iUnicodeEquivalence[30] = 19998; sStringEquivalence[30] = "cheng";
+ iUnicodeEquivalence[31] = 19999; sStringEquivalence[31] = "diu";
+ iUnicodeEquivalence[32] = 20000; sStringEquivalence[32] = "qiu";
+ iUnicodeEquivalence[33] = 20001; sStringEquivalence[33] = "liang";
+ iUnicodeEquivalence[34] = 20002; sStringEquivalence[34] = "diu";
+ iUnicodeEquivalence[35] = 20003; sStringEquivalence[35] = "you";
+ iUnicodeEquivalence[36] = 20004; sStringEquivalence[36] = "liang";
+ iUnicodeEquivalence[37] = 20005; sStringEquivalence[37] = "yan";
+ iUnicodeEquivalence[38] = 20006; sStringEquivalence[38] = "bing";
+ iUnicodeEquivalence[39] = 20007; sStringEquivalence[39] = "sang";
+ iUnicodeEquivalence[40] = 20008; sStringEquivalence[40] = "shu";
+ iUnicodeEquivalence[41] = 20009; sStringEquivalence[41] = "jiu";
+ iUnicodeEquivalence[42] = 20010; sStringEquivalence[42] = "ge";
+ iUnicodeEquivalence[43] = 20011; sStringEquivalence[43] = "ya";
+ iUnicodeEquivalence[44] = 20012; sStringEquivalence[44] = "qiang";
+ iUnicodeEquivalence[45] = 20013; sStringEquivalence[45] = "zhong";
+ iUnicodeEquivalence[46] = 20014; sStringEquivalence[46] = "ji";
+ iUnicodeEquivalence[47] = 20015; sStringEquivalence[47] = "jie";
+ iUnicodeEquivalence[48] = 20016; sStringEquivalence[48] = "feng";
+ iUnicodeEquivalence[49] = 20017; sStringEquivalence[49] = "guan";
+ iUnicodeEquivalence[50] = 20018; sStringEquivalence[50] = "chuan";
+ iUnicodeEquivalence[51] = 20019; sStringEquivalence[51] = "chan";
+ iUnicodeEquivalence[52] = 20020; sStringEquivalence[52] = "lin";
+ iUnicodeEquivalence[53] = 20021; sStringEquivalence[53] = "zhuo";
+ iUnicodeEquivalence[54] = 20022; sStringEquivalence[54] = "zhu";
+ iUnicodeEquivalence[55] = 20024; sStringEquivalence[55] = "wan";
+ iUnicodeEquivalence[56] = 20025; sStringEquivalence[56] = "dan";
+ iUnicodeEquivalence[57] = 20026; sStringEquivalence[57] = "wei";
+ iUnicodeEquivalence[58] = 20027; sStringEquivalence[58] = "zhu";
+ iUnicodeEquivalence[59] = 20028; sStringEquivalence[59] = "jing";
+ iUnicodeEquivalence[60] = 20029; sStringEquivalence[60] = "li";
+ iUnicodeEquivalence[61] = 20030; sStringEquivalence[61] = "ju";
+ iUnicodeEquivalence[62] = 20031; sStringEquivalence[62] = "pie";
+ iUnicodeEquivalence[63] = 20032; sStringEquivalence[63] = "fu";
+ iUnicodeEquivalence[64] = 20033; sStringEquivalence[64] = "yi";
+ iUnicodeEquivalence[65] = 20034; sStringEquivalence[65] = "yi";
+ iUnicodeEquivalence[66] = 20035; sStringEquivalence[66] = "nai";
+ iUnicodeEquivalence[67] = 20037; sStringEquivalence[67] = "jiu";
+ iUnicodeEquivalence[68] = 20038; sStringEquivalence[68] = "jiu";
+ iUnicodeEquivalence[69] = 20039; sStringEquivalence[69] = "tuo";
+ iUnicodeEquivalence[70] = 20040; sStringEquivalence[70] = "me";
+ iUnicodeEquivalence[71] = 20041; sStringEquivalence[71] = "yi";
+ iUnicodeEquivalence[72] = 20043; sStringEquivalence[72] = "zhi";
+ iUnicodeEquivalence[73] = 20044; sStringEquivalence[73] = "wu";
+ iUnicodeEquivalence[74] = 20045; sStringEquivalence[74] = "zha";
+ iUnicodeEquivalence[75] = 20046; sStringEquivalence[75] = "hu";
+ iUnicodeEquivalence[76] = 20047; sStringEquivalence[76] = "fa";
+ iUnicodeEquivalence[77] = 20048; sStringEquivalence[77] = "le";
+ }
+ }
+}
diff --git a/qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java b/qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java
new file mode 100644
index 000000000..001936927
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java
@@ -0,0 +1,86 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+package ifc.i18n;
+
+import com.sun.star.i18n.TransliterationModules;
+import com.sun.star.i18n.XExtendedTransliteration;
+import com.sun.star.lang.Locale;
+import lib.MultiMethodTest;
+
+/**
+ *
+ */
+public class _XExtendedTransliteration extends MultiMethodTest {
+ public XExtendedTransliteration oObj = null;
+ private final Locale loc = new Locale("en", "US", "") ;
+
+ @Override
+ public void before() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+ }
+
+ /**
+ * Check lowercase - uppercase conversion of chars
+ */
+ public void _transliterateChar2Char() {
+ boolean result = true;
+ char in = 'a';
+ char out = ' ';
+ try {
+ out = oObj.transliterateChar2Char(in) ;
+ result &= out == 'A';
+ in = '$'; // should not be changed
+ out = oObj.transliterateChar2Char(in) ;
+ result &= out == '$';
+ }
+ catch(com.sun.star.i18n.MultipleCharsOutputException e) {
+ e.printStackTrace(log);
+ }
+ tRes.tested("transliterateChar2Char()", result);
+ }
+
+ /**
+ * Check lowercase - uppercase conversion of char to string
+ */
+ public void _transliterateChar2String() {
+ boolean result = true;
+ char in = 'a';
+ String out = null;
+ out = oObj.transliterateChar2String('a') ;
+ result &= out.equals("A");
+ in = '$'; // should not be changed
+ out = oObj.transliterateChar2String(in) ;
+ result &= out.equals("$");
+ tRes.tested("transliterateChar2String()", result);
+ }
+
+ /**
+ * Check lowercase - uppercase conversion of strings
+ */
+ public void _transliterateString2String() {
+ boolean result = true;
+ String in = "aAbBcC";
+ String out = null;
+ out = oObj.transliterateString2String(in, 0, 6) ;
+ result &= out.equals("AABBCC");
+ in = "$"; // should not be changed
+ out = oObj.transliterateString2String(in, 0, 1) ;
+ result &= out.equals("$");
+ tRes.tested("transliterateString2String()", result);
+ }
+}
diff --git a/qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java b/qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java
new file mode 100644
index 000000000..31eac7bf6
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java
@@ -0,0 +1,98 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.XIndexEntrySupplier;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XIndexEntrySupplier</code>
+* interface methods:
+* <ul>
+* <li><code> getIndexCharacter() </code></li>
+* <li><code> getIndexFollowPageWord() </code></li>
+* </ul><p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XIndexEntrySupplier
+*/
+public class _XIndexEntrySupplier extends MultiMethodTest {
+ public XIndexEntrySupplier oObj = null;
+ public String[] languages = new String[]{"de","en","es","fr","ja","ko","zh"};
+ public String[] countries = new String[]{"DE","US","ES","FR","JP","KR","CN"};
+ public String[] onePage = new String[]{"f.","p."," s."," sv","p.","",""};
+ public String[] morePages = new String[]{"ff.","pp."," ss."," sv","pp.","",""};
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if the method returns right index for several
+ * locales and word.
+ */
+ public void _getIndexCharacter() {
+ boolean res = true;
+ log.println("getIndexCharacter('chapter', getLocale(i), '')");
+ for (int i=0; i<7; i++) {
+ log.print("getIndexCharacter('chapter', " + countries[i] + ") :");
+ String get = oObj.getIndexCharacter("chapter", getLocale(i), "");
+ log.println(get);
+ res &= get.equals("C");
+ }
+ tRes.tested("getIndexCharacter()", res);
+ }
+
+ /**
+ * Test calls the method with two different parameters: for one page and
+ * for several pages, after every call result is checked. <p>
+ * Has <b> OK </b> status if method returns right index for several locales.
+ */
+ public void _getIndexFollowPageWord() {
+ boolean res = true;
+
+ for (int i=0; i<7; i++) {
+ String get = oObj.getIndexFollowPageWord(true, getLocale(i));
+ if (! get.equals(morePages[i]) ) {
+ log.println("Language: " + languages[i]);
+ log.println("Getting: #" + get + "#");
+ log.println("Expected: #" + morePages[i] + "#");
+ }
+ res &= get.equals(morePages[i]);
+ get = oObj.getIndexFollowPageWord(false,getLocale(i));
+ if (! get.equals(onePage[i]) ) {
+ log.println("Language: " + languages[i]);
+ log.println("Getting: #" + get + "#");
+ log.println("Expected: #" + onePage[i] + "#");
+ }
+ res &= get.equals(onePage[i]);
+ }
+ tRes.tested("getIndexFollowPageWord()", res);
+ }
+
+ /**
+ * Method returns locale for a given language and country.
+ * @param k index of needed locale.
+ * @return Locale by the index from arrays defined above
+ */
+ public Locale getLocale(int k) {
+ return new Locale(languages[k], countries[k], "");
+ }
+
+
+} // end XIndexEntrySupplier
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XLocaleData.java b/qadevOOo/tests/java/ifc/i18n/_XLocaleData.java
new file mode 100644
index 000000000..e7060dcb2
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XLocaleData.java
@@ -0,0 +1,467 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.Calendar;
+import com.sun.star.i18n.Currency;
+import com.sun.star.i18n.ForbiddenCharacters;
+import com.sun.star.i18n.FormatElement;
+import com.sun.star.i18n.Implementation;
+import com.sun.star.i18n.LanguageCountryInfo;
+import com.sun.star.i18n.LocaleDataItem;
+import com.sun.star.i18n.XLocaleData;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XLocaleData</code>
+* interface methods:
+* <ul>
+* <li><code> getLanguageCountryInfo() </code></li>
+* <li><code> getLocaleItem() </code></li>
+* <li><code> getAllCalendars() </code></li>
+* <li><code> getAllCurrencies() </code></li>
+* <li><code> getAllFormats() </code></li>
+* <li><code> getCollatorImplementations() </code></li>
+* <li><code> getSearchOptions() </code></li>
+* <li><code> getCollationOptions() </code></li>
+* <li><code> getTransliterations() </code></li>
+* <li><code> getForbiddenCharacters() </code></li>
+* <li><code> getReservedWord() </code></li>
+* <li><code> getAllInstalledLocaleNames() </code></li>
+* </ul><p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XLocaleData
+*/
+public class _XLocaleData extends MultiMethodTest {
+ public XLocaleData oObj = null;
+ public String[] languages = new String[]{"de","en","es","fr","ja","ko","ko"};
+ public String[] countries = new String[]{"DE","US","ES","FR","JP","KR","KR"};
+
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if structure, returned by the method includes
+ * correct values of fields 'Language' and 'Country' for all given locales.
+ */
+ public void _getLanguageCountryInfo() {
+ boolean res = true;
+ LanguageCountryInfo lci = null;
+
+ for (int i=0;i<7;i++) {
+ lci = oObj.getLanguageCountryInfo(getLocale(i));
+ /* For debug purposes
+ log.println("Using: language="+languages[i]+" ; country="+countries[i]);
+ log.println("Getting: ");
+ log.println("\t Language="+lci.Language);
+ log.println("\t LanguageDefaultName="+lci.LanguageDefaultName);
+ log.println("\t Country="+lci.Country);
+ log.println("\t CountryDefaultName="+lci.CountryDefaultName);
+ boolean lang = ( lci.Language.equals(languages[i]) );
+ if (!lang) log.println("getting false for language: "+lci.LanguageDefaultName);
+ lang = ( lci.Country.equals(countries[i]) );
+ if (!lang) log.println("getting false for country: "+lci.CountryDefaultName);
+ */
+ res &= ( ( lci.Language.equals(languages[i]) ) && ( lci.Country.equals(countries[i]) ) );
+ }
+ tRes.tested("getLanguageCountryInfo()",res);
+ }
+
+ /**
+ * Test calls the method, then result is checked. <p>
+ * Has <b> OK </b> status if structure, returned by the method consists of
+ * non empty strings for all given locales.
+ */
+ public void _getLocaleItem() {
+ boolean res = true;
+ LocaleDataItem ldi = null;
+
+ for (int i=0;i<7;i++) {
+ ldi = oObj.getLocaleItem(getLocale(i));
+
+ boolean locRes = true ;
+
+ locRes &= (! ldi.dateSeparator.equals(""));
+ locRes &= (! ldi.decimalSeparator.equals(""));
+ locRes &= (! ldi.doubleQuotationEnd.equals(""));
+ locRes &= (! ldi.doubleQuotationStart.equals(""));
+ locRes &= (! ldi.listSeparator.equals(""));
+ locRes &= (! ldi.LongDateDayOfWeekSeparator.equals(""));
+ locRes &= (! ldi.LongDateDaySeparator.equals(""));
+ locRes &= (! ldi.LongDateMonthSeparator.equals(""));
+ locRes &= (! ldi.LongDateYearSeparator.equals(""));
+ locRes &= (! ldi.measurementSystem.equals(""));
+ locRes &= (! ldi.quotationEnd.equals(""));
+ locRes &= (! ldi.quotationStart.equals(""));
+ locRes &= (! ldi.thousandSeparator.equals(""));
+ locRes &= (! ldi.time100SecSeparator.equals(""));
+ locRes &= (! ldi.timeAM.equals(""));
+ locRes &= (! ldi.timePM.equals(""));
+ locRes &= (! ldi.timeSeparator.equals(""));
+ locRes &= (! ldi.unoID.equals(""));
+
+ if (!locRes) {
+ /* for debugging purposes
+ log.println("FAILED for: language="+languages[i]+" ; country="+countries[i]);
+ log.println("Getting: ");
+ log.println("\t DateSeparator="+ldi.dateSeparator);
+ log.println("\t decimalSeparator="+ldi.decimalSeparator);
+ log.println("\t doubleQuotationEnd="+ldi.doubleQuotationEnd);
+ log.println("\t doubleQuotationStart="+ldi.doubleQuotationStart);
+ log.println("\t listSeparator="+ldi.listSeparator);
+ log.println("\t LongDateDayOfWeekSeparator="+ldi.LongDateDayOfWeekSeparator+"end");
+ log.println("\t LongDateDaySeparator="+ldi.LongDateDaySeparator+"end");
+ log.println("\t LongDateMonthSeparator="+ldi.LongDateMonthSeparator+"end");
+ log.println("\t LongDateYearSeparator="+ldi.LongDateYearSeparator+"end");
+ log.println("\t measurementSystem="+ldi.measurementSystem);
+ log.println("\t quotationEnd="+ldi.quotationEnd);
+ log.println("\t quotationStart="+ldi.quotationStart);
+ log.println("\t thousandSeparator="+ldi.thousandSeparator);
+ log.println("\t time100SecSeparator="+ldi.time100SecSeparator);
+ log.println("\t timeAM="+ldi.timeAM);
+ log.println("\t timePM="+ldi.timePM);
+ log.println("\t timeSeparator="+ldi.timeSeparator);
+ log.println("\t unoID="+ldi.unoID);
+ */
+ }
+ }
+ tRes.tested("getLocaleItem()",res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all elements of the returned sequence are
+ * correct for all given locales. (boolean method goodCalendar() with a
+ * calendar as an argument returns true)
+ */
+ public void _getAllCalendars() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ Calendar[] calendar = oObj.getAllCalendars(getLocale(i));
+ for (int j=0;j<calendar.length;j++) {
+ if (! goodCalendar(calendar[j]) ) {
+ printit = true;
+ }
+ res &= goodCalendar(calendar[j]);
+ }
+ if (printit) log.println("FAILED for: language="+languages[i]+" ; country="+countries[i]);
+ printit = false;
+ }
+ tRes.tested("getAllCalendars()", res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all elements of the returned sequence are
+ * correct for all given locales. (boolean method goodCurrency() with a
+ * currency as an argument returns true)
+ */
+ public void _getAllCurrencies() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ Currency[] currency = oObj.getAllCurrencies(getLocale(i));
+ for (int j=0;j<currency.length;j++) {
+ if (! goodCurrency(currency[j]) ) {
+ printit=true;
+ }
+ res &= goodCurrency(currency[j]);
+ }
+ if (printit) log.println("FAILED for: language="+languages[i]+" ; country="+countries[i]);
+ printit =false;
+ }
+ tRes.tested("getAllCurrencies()",res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all elements of the returned sequence are
+ * correct for all given locales. (boolean method goodFormat() with a
+ * format as an argument returns true)
+ */
+ public void _getAllFormats() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ FormatElement[] format = oObj.getAllFormats(getLocale(i));
+ for (int j=0;j<format.length;j++) {
+ if (! goodFormat(format[j]) ) {
+ printit = true;
+ }
+ res &= goodFormat(format[j]);
+ }
+ if (printit) log.println("FAILED for: language="+languages[i]+" ; country="+countries[i]);
+ printit =false;
+ }
+ tRes.tested("getAllFormats()",res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all structs, returned by the method have non
+ * empty field 'UnoID' for all given locales.
+ */
+ public void _getCollatorImplementations() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ Implementation[] impl = oObj.getCollatorImplementations(getLocale(i));
+ for (int j=0;j<impl.length;j++) {
+ if (impl[j].unoID.equals("")) {
+ printit = true;
+ }
+ res &= (!impl[j].unoID.equals(""));
+ }
+ if (printit) log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ printit = false;
+ }
+ tRes.tested("getCollatorImplementations()", res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all strings, returned by the method are not
+ * empty for all given locales.
+ */
+ public void _getSearchOptions() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ String[] str = oObj.getSearchOptions(getLocale(i));
+ for (int j=0;j<str.length;j++) {
+ if (str[j].equals("")) {
+ printit = true;
+ }
+ res &= (!str[j].equals(""));
+ }
+ if (printit) log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ printit = false;
+ }
+ tRes.tested("getSearchOptions()",res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all strings, returned by the method are not
+ * empty for all given locales.
+ */
+ public void _getCollationOptions() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ String[] str = oObj.getCollationOptions(getLocale(i));
+ for (int j=0;j<str.length;j++) {
+ if (str[j].equals("")) {
+ printit = true;
+ }
+ res &= (!str[j].equals(""));
+ }
+ if (printit) log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ printit = false;
+ }
+ tRes.tested("getCollationOptions()", res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all strings, returned by the method are not
+ * empty for all given locales.
+ */
+ public void _getTransliterations() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ String[] str = oObj.getTransliterations(getLocale(i));
+ for (int j=0;j<str.length;j++) {
+ if (str[j].equals("")) {
+ printit = true;
+ }
+ res &= (!str[j].equals(""));
+ }
+ if (printit) log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ printit = false;
+ }
+ tRes.tested("getTransliterations()", res);
+ }
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if the method returns structure with non-empty
+ * fields for all given locales.
+ */
+ public void _getForbiddenCharacters() {
+ boolean res = true;
+ ForbiddenCharacters fc = null;
+
+ //the forbidden characters are only available for the asian languages
+ for (int i=4;i<7;i++) {
+ fc = oObj.getForbiddenCharacters(getLocale(i));
+ res &= !( fc.beginLine.equals("") || fc.endLine.equals("") );
+ if ( !res ) {
+ log.println("FAILED for: language="+languages[i]+" ; country="+countries[i]);
+ }
+ }
+ tRes.tested("getForbiddenCharacters()", res);
+ }
+
+
+ /**
+ * Test calls the method for several locales; result is checked
+ * after each call. <p>
+ * Has <b> OK </b> status if all strings, returned by the method are not
+ * empty for all given locales.
+ */
+ public void _getReservedWord() {
+ boolean res = true;
+ boolean printit = false;
+
+ for (int i=0;i<7;i++) {
+ String[] str = oObj.getReservedWord(getLocale(i));
+ for (int j=0;j<str.length;j++) {
+ if (str[j].equals("")) {
+ printit = true;
+ }
+ res &= (!str[j].equals(""));
+ }
+ if (printit) log.println("FAILED for: language=" + languages[i]
+ + " ; country=" + countries[i]);
+ printit = false;
+ }
+ tRes.tested("getReservedWord()", res);
+ }
+
+
+ /**
+ * Test calls the method. Then result is checked for all given locales.<p>
+ * Has <b> OK </b> status if locale sequence, returned by the method contains
+ * given locales.
+ */
+ public void _getAllInstalledLocaleNames() {
+ boolean res = true;
+ Locale[] locs = oObj.getAllInstalledLocaleNames();
+
+ //check if the languages used here are part of this array
+ for (int i=0;i<7;i++) {
+ res &= contains(locs, getLocale(i));
+ }
+ tRes.tested("getAllInstalledLocaleNames()",res);
+ }
+
+
+ /**
+ * Method returns locale for a given language and country.
+ * @param k index of needed locale.
+ * @return Locale by the index from arrays defined above
+ */
+ public Locale getLocale(int k) {
+ return new Locale(languages[k],countries[k],"");
+ }
+
+ /**
+ * Method checks given calendar for non empty fields.
+ * @param calendar Calendar to be checked
+ */
+ public boolean goodCalendar(Calendar calendar) {
+ boolean good = true;
+ for (int i=0;i<calendar.Days.length;i++) {
+ good &= (! calendar.Days[i].AbbrevName.equals("") );
+ good &= (! calendar.Days[i].FullName.equals("") );
+ good &= (! calendar.Days[i].ID.equals("") );
+ }
+ for (int i=0;i<calendar.Months.length;i++) {
+ good &= (! calendar.Months[i].AbbrevName.equals("") );
+ good &= (! calendar.Months[i].FullName.equals("") );
+ good &= (! calendar.Months[i].ID.equals("") );
+ }
+ for (int i=0;i<calendar.Eras.length;i++) {
+ good &= (! calendar.Eras[i].AbbrevName.equals("") );
+ good &= (! calendar.Eras[i].FullName.equals("") );
+ good &= (! calendar.Eras[i].ID.equals("") );
+ }
+ good &= (! calendar.StartOfWeek.equals("") );
+ good &= (! calendar.Name.equals("") );
+ return good;
+ }
+
+ /**
+ * Method checks given currency for non empty fields.
+ * @param currency Currency to be checked
+ */
+ public boolean goodCurrency(Currency currency) {
+ boolean good = true;
+ good &= (!currency.BankSymbol.equals(""));
+ good &= (!currency.Name.equals(""));
+ good &= (!currency.Symbol.equals(""));
+ return good;
+ }
+
+ /**
+ * Method checks given format for non empty fields.
+ * @param format Format to be checked
+ */
+ public boolean goodFormat(FormatElement format) {
+ boolean good = true;
+ good &= (!format.formatCode.equals(""));
+ good &= (!format.formatKey.equals(""));
+ good &= (!format.formatType.equals(""));
+ good &= (!format.formatUsage.equals(""));
+ return good;
+ }
+
+ /**
+ * Method checks that locale sequence contains given locale.
+ * @param locs Locale sequence
+ * @param oneLoc given locale
+ */
+ public boolean contains(Locale[] locs, Locale oneLoc) {
+ boolean cont = false;
+ for (int j=0;j<locs.length;j++) {
+ if ( (locs[j].Country.equals(oneLoc.Country)) &&
+ (locs[j].Language.equals(oneLoc.Language)) ) {
+ cont=true;
+ break;
+ }
+ }
+ if (!cont) log.println("Not contained: " + oneLoc.Language);
+ return cont;
+ }
+
+} // end XLocaleData
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java b/qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java
new file mode 100644
index 000000000..5adddb189
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java
@@ -0,0 +1,154 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.KNumberFormatType;
+import com.sun.star.i18n.KNumberFormatUsage;
+import com.sun.star.i18n.NumberFormatCode;
+import com.sun.star.i18n.NumberFormatIndex;
+import com.sun.star.i18n.XNumberFormatCode;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XNumberFormatCode</code>
+* interface methods:
+* <ul>
+* <li><code> getDefault() </code></li>
+* <li><code> getFormatCode() </code></li>
+* <li><code> getAllFormatCode() </code></li>
+* <li><code> getAllFormatCodes() </code></li>
+* </ul><p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XNumberFormatCode
+*/
+public class _XNumberFormatCode extends MultiMethodTest {
+ public XNumberFormatCode oObj = null;
+ public String[] languages = new String[]
+ {"de","en","es","fr","ko","ko","zh"};
+ public String[] countries = new String[]
+ {"DE","US","ES","FR","KR","KR","CN"};
+
+ /**
+ * Test calls the method twice with two different format types as
+ * parameters for each locale. Result is checked after every call.<p>
+ * Has <b> OK </b> status if both times returned structure's field 'Code'
+ * does not equal to empty string.
+ */
+ public void _getDefault() {
+ boolean res = true;
+ NumberFormatCode nfc = null;
+
+ for (int i=0;i<7;i++) {
+ nfc = oObj.getDefault(KNumberFormatType.SHORT,
+ KNumberFormatUsage.DATE, getLocale(i));
+ String str = nfc.Code;
+ if (str.equals("")) {
+ log.println("'NumberFormat.code.equals(\"\") = true' for"
+ + " language: " + languages[i]);
+ log.println("Usage: oObj.getDefault(KNumberFormatType.SHORT,"
+ + " KNumberFormatUsage.DATE,new Locale(" + languages[i]
+ + "," + countries[i] + ",\"\");");
+ }
+ res &= !str.equals("");
+
+ nfc = oObj.getDefault(KNumberFormatType.LONG,
+ KNumberFormatUsage.DATE,getLocale(i));
+ str = nfc.Code;
+ if (str.equals("")) {
+ log.println("'NumberFormat.code.equals(\"\") = true' for "
+ + "language: " + languages[i]);
+ log.println("Usage: oObj.getDefault(KNumberFormatType.LONG,"
+ + " KNumberFormatUsage.DATE,new Locale(" + languages[i]
+ + "," + countries[i] + ",\"\");");
+ }
+ res &= ( ! str.equals("") );
+ }
+ tRes.tested("getDefault()", res);
+ }
+
+ /**
+ * Test calls the method twice for each locale with two different arguments.
+ * After every call result is checked.<p>
+ * Has <b> OK </b> status if both times returned structure's field 'Code'
+ * does not equal to an empty string.
+ */
+ public void _getFormatCode() {
+ boolean res = true;
+ NumberFormatCode nfc = null;
+
+ for (int i=0;i<7;i++) {
+ nfc = oObj.getFormatCode
+ (NumberFormatIndex.DATE_SYSTEM_SHORT,getLocale(i));
+ res &= ( ! nfc.Code.equals("") );
+ nfc = oObj.getFormatCode
+ (NumberFormatIndex.DATE_SYSTEM_LONG,getLocale(i));
+ res &= ( ! nfc.Code.equals("") );
+ }
+ tRes.tested("getFormatCode()", res);
+ }
+
+ /**
+ * Test calls the method twice with two different arguments for each locale.
+ * After every call result is checked.<p>
+ * Has <b> OK </b> status if both times returned array's length does not
+ * equal to zero.
+ */
+ public void _getAllFormatCode() {
+ boolean res = true;
+ NumberFormatCode[] nfc = null;
+
+ for (int i=0;i<7;i++) {
+ nfc = oObj.getAllFormatCode(KNumberFormatUsage.DATE, getLocale(i));
+ res &= ( nfc.length != 0 );
+ nfc = oObj.getAllFormatCode(KNumberFormatUsage.TIME, getLocale(i));
+ res &= ( nfc.length != 0 );
+ }
+ tRes.tested("getAllFormatCode()", res);
+ }
+
+ /**
+ * Test calls the method for each locale. <p>
+ * Has <b> OK </b> status if returned array's length does not equal to zero.
+ */
+ public void _getAllFormatCodes() {
+ boolean res = true;
+ NumberFormatCode[] nfc = null;
+
+ for (int i=0;i<7;i++) {
+ nfc = oObj.getAllFormatCodes(getLocale(i));
+ res &= ( nfc.length != 0 );
+ }
+ tRes.tested("getAllFormatCodes()", res);
+ }
+
+ /**
+ * Method returns locale for a given language and country.
+ * @param k index of needed locale.
+ * @return Locale by the index from arrays defined above
+ */
+ public Locale getLocale(int k) {
+ return new Locale(languages[k], countries[k], "");
+ }
+
+
+
+} // end XNumberFormatCode
+
diff --git a/qadevOOo/tests/java/ifc/i18n/_XTransliteration.java b/qadevOOo/tests/java/ifc/i18n/_XTransliteration.java
new file mode 100644
index 000000000..d041d425d
--- /dev/null
+++ b/qadevOOo/tests/java/ifc/i18n/_XTransliteration.java
@@ -0,0 +1,445 @@
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you 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 .
+ */
+
+package ifc.i18n;
+
+import lib.MultiMethodTest;
+
+import com.sun.star.i18n.TransliterationModules;
+import com.sun.star.i18n.TransliterationModulesNew;
+import com.sun.star.i18n.TransliterationType;
+import com.sun.star.i18n.XTransliteration;
+import com.sun.star.lang.Locale;
+
+/**
+* Testing <code>com.sun.star.i18n.XTransliteration</code>
+* interface methods :
+* <ul>
+* <li><code> getName()</code></li>
+* <li><code> getType()</code></li>
+* <li><code> loadModule()</code></li>
+* <li><code> loadModuleNew()</code></li>
+* <li><code> loadModuleByImplName()</code></li>
+* <li><code> loadModulesByImplNames()</code></li>
+* <li><code> getAvailableModules()</code></li>
+* <li><code> transliterate()</code></li>
+* <li><code> folding()</code></li>
+* <li><code> equals()</code></li>
+* <li><code> transliterateRange()</code></li>
+* </ul> <p>
+* Test is <b> NOT </b> multithread compliant. <p>
+* @see com.sun.star.i18n.XTransliteration
+*/
+public class _XTransliteration extends MultiMethodTest {
+
+ public XTransliteration oObj = null;
+ private final Locale loc = new Locale("en", "EN", "") ;
+
+ /**
+ * Gets all available transliteration modules. <p>
+ * Has <b>OK</b> status if array returned has at least
+ * one module name.
+ */
+ public void _getAvailableModules() {
+ String[] mod = oObj.getAvailableModules(loc, TransliterationType.ONE_TO_ONE);
+
+ if (mod != null) {
+ log.println("Available modules :") ;
+ for (int i = 0; i < mod.length; i++) {
+ log.println(" '" + mod[i] + "'") ;
+ }
+ } else {
+ log.println("!!! NULL returned !!!") ;
+ }
+
+ tRes.tested("getAvailableModules()", mod != null && mod.length > 0) ;
+ }
+
+ /**
+ * Calls the method for load IGNORE_CASE module and checks the name returned
+ * by the method <code>getName</code>. <p>
+ * Has <b>OK</b> status if the method <code>getName</code> returns the
+ * string "case ignore (generic)".
+ */
+ public void _loadModule() {
+ log.println("Load module IGNORE_CASE");
+ oObj.loadModule(TransliterationModules.IGNORE_CASE, loc);
+
+ String name = oObj.getName();
+ boolean res = name.equals("case ignore (generic)");
+ log.println("getName return: " + name);
+
+ tRes.tested("loadModule()", res );
+ }
+
+ /**
+ * Loads <code>LOWERCASE_UPPERCASE</code> module and checks the current
+ * name of object. <p>
+ *
+ * Has <b>OK</b> status if the name of the object is equals to
+ * 'lower_to_upper(generic)'
+ */
+ public void _loadModuleNew() {
+ boolean result = true ;
+
+ oObj.loadModuleNew(
+ new TransliterationModulesNew[]
+ {TransliterationModulesNew.LOWERCASE_UPPERCASE}, loc);
+
+ String name = oObj.getName();
+ result = name.equals("lower_to_upper(generic)");
+ log.println("getName return: " + name);
+
+ tRes.tested("loadModuleNew()", result);
+ }
+
+ /**
+ * Calls the method for load LOWERCASE_UPPERCASE module and
+ * checks the name returned by the method <code>getName</code>. <p>
+ * Has <b>OK</b> status if the method <code>getName</code> returns the
+ * string "lower_to_upper(generic)".
+ */
+ public void _loadModuleByImplName() {
+ log.println("Load module LOWERCASE_UPPERCASE");
+ oObj.loadModuleByImplName("LOWERCASE_UPPERCASE", loc);
+
+ String name = oObj.getName();
+ boolean res = name.equals("lower_to_upper(generic)");
+ log.println("getName return: " + name);
+
+ tRes.tested("loadModuleByImplName()", res);
+ }
+
+ /**
+ * Calls the method for load UPPERCASE_LOWERCASE module and
+ * checks the name returned by the method <code>getName</code>. <p>
+ * Has <b>OK</b> status if the method <code>getName</code> returns the
+ * string "upper_to_lower(generic)".
+ */
+ public void _loadModulesByImplNames() {
+ log.println("Load module UPPERCASE_LOWERCASE");
+ oObj.loadModulesByImplNames(new String[]{"UPPERCASE_LOWERCASE"}, loc);
+
+ String name = oObj.getName();
+ boolean res = name.equals("upper_to_lower(generic)");
+ log.println("getName return: " + name);
+
+ tRes.tested("loadModulesByImplNames()", res);
+ }
+
+ /**
+ * Loads <code>LOWERCASE_UPPERCASE</code> module and checks current type.
+ * <p>Has <b>OK</b> status if the type is <code>ONE_TO_ONE</code>
+ */
+ public void _getType() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+ boolean result = oObj.getType() == TransliterationType.ONE_TO_ONE;
+ tRes.tested("getType()", result);
+ }
+
+ /**
+ * Loads UPPERCASE_LOWERCASE module and
+ * checks the name returned by the method <code>getName</code>. <p>
+ *
+ * Has <b>OK</b> status if the method <code>getName</code> returns the
+ * string "upper_to_lower(generic)".
+ */
+ public void _getName() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+
+ String name = oObj.getName();
+ boolean res = name.equals("lower_to_upper(generic)");
+ log.println("getName return: " + name);
+
+ tRes.tested("getName()", res);
+ }
+
+ /**
+ * First loads <code>LOWERCASE_UPPERCASE</code> module.
+ * Then tries to transliterate (make uppercase) a substring. <p>
+ * Has <b>OK</b> status if all chars were made uppercase,
+ * and array returned has size as substring length, and its
+ * elements are positions of substring characters in the source
+ * string.
+ */
+ public void _transliterate() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+
+ int[][] offs = new int[1][] ;
+
+ String out = oObj.transliterate("AaBbCc", 1, 4, offs) ;
+
+ boolean result = "ABBC".equals(out) && offs[0].length == 4 &&
+ offs[0][0] == 1 &&
+ offs[0][1] == 2 &&
+ offs[0][2] == 3 &&
+ offs[0][3] == 4 ;
+
+ tRes.tested("transliterate()", result) ;
+ }
+
+
+ /**
+ * First loads <code>LOWERCASE_UPPERCASE</code> module.
+ * Tries to transliterate a range of two characters. <p>
+ * Has <b>OK</b> status if the appropriate String array
+ * returned (not null, length = 4, with two ranges
+ * (a, i), (A, I) in any order).
+ */
+ public void _transliterateRange() {
+ oObj.loadModule(TransliterationModules.IGNORE_CASE, loc);
+
+ String[] out = oObj.transliterateRange("a", "i") ;
+
+ log.println("transliterateRange return:");
+ for(int i = 0; i < out.length; i++) {
+ log.println(out[i]);
+ }
+
+ boolean bOK = out.length == 4 &&
+ ("A".equals(out[0]) && "I".equals(out[1]) &&
+ "a".equals(out[2]) && "i".equals(out[3])) ||
+ ("a".equals(out[0]) && "i".equals(out[1]) &&
+ "A".equals(out[2]) && "I".equals(out[3])) ;
+
+ if (!bOK) {
+ log.println("Unexpected range returned :");
+ for (int i = 0; i < out.length; i++) {
+ log.print("'" + out[i] +"', ");
+ }
+ log.println();
+ }
+
+ tRes.tested("transliterateRange()", bOK);
+ }
+
+ /**
+ * This method is used internally by <code>equals</code>
+ * method so it indirectly tested in this method. <p>
+ * Always has <b>OK</b> status.
+ */
+ public void _folding() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+
+ int[][] offs = new int[1][] ;
+
+ String out = oObj.folding("AaBbCc", 1, 4, offs) ;
+
+ boolean result = "ABBC".equals(out) && offs[0].length == 4 &&
+ offs[0][0] == 1 &&
+ offs[0][1] == 2 &&
+ offs[0][2] == 3 &&
+ offs[0][3] == 4 ;
+
+
+ tRes.tested("folding()", result) ;
+ }
+
+
+ /**
+ * First loads <code>LOWERCASE_UPPERCASE</code> module.
+ * Tries to compare two equal substrings. <p>
+ * Has <b>OK</b> status if the method returned <code>true</code>.
+ */
+ public void _equals() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+
+ int[] match1 = new int[1],
+ match2 = new int[1] ;
+
+ boolean res = oObj.equals("aAbBcC", 1, 3, match1, "aAbBcC", 1,
+ 3, match2) ;
+
+ log.println("Returned : " + res + " Match1 = " + match1[0] +
+ " Match2 = " + match2[0]) ;
+
+ tRes.tested("equals()", res) ;
+ }
+
+ /**
+ * Test performed for sets of equal substrings, not equal
+ * substrings, and without of bounds offset and length
+ * parameters.<p>
+ *
+ * Has <b>OK</b> status if comparings of equal substrings
+ * always return 0, if comparisons of none equal returns
+ * proper value according to lexicographical order and if
+ * comparisons with invalid parameters return none 0 value.
+ */
+ public void _compareSubstring() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+ boolean result = true ;
+
+ // substrings below must be equal
+ result &= testSubstring("", 0, 0, "", 0, 0, 0) ;
+ result &= testSubstring("aa", 1, 0, "", 0, 0, 0) ;
+ result &= testSubstring("aa", 1, 0, "aa", 2, 0, 0) ;
+ result &= testSubstring("a", 0, 1, "a", 0, 1, 0) ;
+ result &= testSubstring("ab", 0, 2, "ab", 0, 2, 0) ;
+ result &= testSubstring("abc", 1, 2, "abc", 1, 2, 0) ;
+ result &= testSubstring("abcdef", 0, 3, "123abc", 3, 3, 0) ;
+ result &= testSubstring("abcdef", 1, 1, "123abc", 4, 1, 0) ;
+
+ // substrings below must NOT be equal
+ result &= testSubstring("a", 0, 1, "a", 0, 0, 1) ;
+ result &= testSubstring("aaa", 1, 1, "", 0, 0, 1) ;
+ result &= testSubstring("bbb", 2, 1, "aaa", 2, 1, 1) ;
+ result &= testSubstring("abc", 0, 3, "abc", 0, 2, 1) ;
+ result &= testSubstring("bbc", 1, 2, "bbc", 0, 2, 1) ;
+
+ // testing with wrong offsets and lengths
+
+ tRes.tested("compareSubstring()", result) ;
+ }
+
+ /**
+ * Performs tesing of two substrings. Also testing of opposite
+ * substrings order performed.
+ * @return <code>true</code> if substrings are equal and returned
+ * value is 0 for both orders,
+ * if substrings are different and expected value
+ * returned for direct order and opposite value returned for
+ * opposite order.
+ */
+ private boolean testSubstring(String str1, int p1, int len1,
+ String str2, int p2, int len2, int expRes) {
+
+ boolean ret = true ;
+
+ int res = -666 ;
+ try {
+ res = oObj.compareSubstring(str1, p1, len1, str2, p2, len2);
+ } catch (NullPointerException e) {
+ log.println("Exception while method calling occurs :" + e);
+ }
+
+ if (res != expRes) {
+ log.print("Comparing FAILED; return: " + res + ", expected: " +
+ expRes + " ");
+ ret = false ;
+ } else {
+ log.print("Comparing OK : ");
+ }
+ log.println("('" + str1 + "', " + p1 + ", " + len1 + ", '" +
+ str2 + "', " + p2 + ", " + len2 + ")");
+
+ res = -666 ;
+ try {
+ res = oObj.compareSubstring(str2, p2, len2, str1, p1, len1);
+ } catch (NullPointerException e) {
+ log.println("Exception while method calling occurs :" + e);
+ }
+
+ if (res != -expRes) {
+ log.print("Comparing FAILED; return: " + res + ", expected: " +
+ -expRes + " ");
+ ret = false ;
+ } else {
+ log.print("Comparing OK :");
+ }
+ log.println("('" + str2 + "', " + p2 + ", " + len2 + ", '" +
+ str1 + "', " + p1 + ", " + len1 + ")");
+
+ return ret ;
+ }
+
+ /**
+ * Test performed for sets of equal strings and not equal
+ * strings.<p>
+ *
+ * Has <b>OK</b> status if comparings of equal strings
+ * always return 0 and if comparisons of none equal returns
+ * proper value according to lexicographical order .
+ */
+ public void _compareString() {
+ oObj.loadModule(TransliterationModules.LOWERCASE_UPPERCASE, loc);
+ boolean result = true ;
+
+ result &= testString("", "", 0) ;
+ result &= testString("a", "", 1) ;
+ result &= testString("a", "a", 0) ;
+ result &= testString("A", "a", 0) ;
+ result &= testString("b", "a", 1) ;
+ result &= testString("\n", "\n", 0) ;
+ result &= testString("\n", "\t", 1) ;
+ result &= testString("aaa", "aaa", 0) ;
+ result &= testString("aaA", "aaa", 0) ;
+ result &= testString("aaa", "aa", 1) ;
+ result &= testString("ab", "aaa", 1) ;
+ result &= testString("aba", "aa", 1) ;
+ result &= testString("aaa\t\na", "aaa\t\na", 0) ;
+ result &= testString("aaa\t\nb", "aaa\t\na", 1) ;
+
+ tRes.tested("compareString()", result) ;
+ }
+
+ /**
+ * Performs tesing of two strings. If the expected value is not 0
+ * (i.e. strings are not equal), then also testing of opposite
+ * strings order performed.
+ * @return <code>true</code> if strings are equal and returned
+ * value is 0, if strings are different and expected value
+ * returned for direct order and opposite value returned for
+ * opposite order.
+ */
+ protected boolean testString(String str1, String str2, int expRes) {
+ if (expRes == 0) return testString(str1, str2, expRes, false) ;
+ return testString(str1, str2, expRes, true) ;
+ }
+
+ private boolean testString(String str1, String str2, int expRes,
+ boolean testReverse) {
+
+ boolean ret = true ;
+
+ int res = -666 ;
+ try {
+ res = oObj.compareString(str1, str2);
+ } catch (NullPointerException e) {
+ log.println("Exception while method calling occurs :" + e);
+ }
+
+ if (res == expRes) {
+ log.println("Comparing of '" + str1 + "' and '" + str2 + "' OK" );
+ } else {
+ log.println("Comparing of '" + str1 + "' and '" + str2 +
+ "' FAILED; return: " + res + ", expected: " + expRes);
+ ret = false ;
+ }
+
+ if (!testReverse) return ret ;
+
+ res = -666 ;
+ try {
+ res = oObj.compareString(str2, str1);
+ } catch (NullPointerException e) {
+ log.println("Exception while method calling occurs :" + e);
+ }
+
+ if (res == -expRes) {
+ log.println("Comparing of '" + str2 + "' and '" + str1 + "' OK" );
+ } else {
+ log.println("Comparing of '" + str2 + "' and '" + str1 +
+ "' FAILED; return: " + res + ", expected: " + -expRes);
+ ret = false ;
+ }
+
+ return ret ;
+ }
+}
+