diff options
Diffstat (limited to 'qadevOOo/tests/java/ifc/i18n')
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java | 681 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XCalendar.java | 561 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java | 416 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XCollator.java | 430 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java | 138 | ||||
| -rwxr-xr-x | qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java | 336 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java | 95 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java | 107 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XLocaleData.java | 497 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java | 163 | ||||
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XTransliteration.java | 456 |
11 files changed, 3880 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 000000000000..7589bc8774c8 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java @@ -0,0 +1,681 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +package ifc.i18n; + +import java.util.Vector; + +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. + */ + 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); + } + + Vector vBounds = new Vector(); + + /** + * 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; + Vector vPrevBounds = new Vector(); + 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 = (Boundary)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 = (Boundary)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 = (Boundary)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 = (Boundary)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); + } + + Vector vSentenceStart = new Vector(); + /** + * 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 = new Integer( 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 = ((Integer)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 begining 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 ACSII 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; + } + + Vector vCharBlockBounds = new Vector(); + Vector vCharBlockTypes = new Vector(); + + /** + * 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(new Short(charType)); + } + + for(int i = 0; i < vCharBlockBounds.size() - 1; i++) { + int endPos = ((Boundary)vCharBlockBounds.get(i)).endPos; + int startPos = ((Boundary)vCharBlockBounds.get(i + 1)).startPos; + bCharBlockRes &= endPos == startPos; + } + + log.println("Testing for no intersections : " + bCharBlockRes); + int startPos = ((Boundary)vCharBlockBounds.get(0)).startPos; + bCharBlockRes &= startPos == 0; + int endPos = ((Boundary)vCharBlockBounds.get + (vCharBlockBounds.size() - 1)).endPos; + bCharBlockRes &= endPos == UnicodeString.length(); + 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 = (Boundary)vCharBlockBounds.get(i); + Short type = (Short)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 = (Boundary)vCharBlockBounds.get(i); + Short type = (Short)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 000000000000..5453eefa49cb --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XCalendar.java @@ -0,0 +1,561 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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.lang.XMultiServiceFactory; +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 compilant. <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; + + public void before() { + XLocaleData locData = null; + try { + locData = (XLocaleData) UnoRuntime.queryInterface( + XLocaleData.class, + ((XMultiServiceFactory)tParam.getMSF()).createInstance( + "com.sun.star.i18n.LocaleData")); + } catch (com.sun.star.uno.Exception e) { + + } + installed_locales = locData.getAllInstalledLocaleNames(); + calendars = new String[installed_locales.length][]; + count = new int[installed_locales.length]; + 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. + */ + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 + " ... OK"); + } else { + 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 occure: 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("expexted: " + 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("expexted: " + 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); + } + + /** + * Method returns locale for a given language and country. + * @param localeIndex index of needed locale. + */ +/* public Locale getLocale(int localeIndex) { + return new Locale(languages[localeIndex], countries[localeIndex], ""); + }*/ + +} + diff --git a/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java b/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java new file mode 100644 index 000000000000..e81b8aa68307 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XCharacterClassification.java @@ -0,0 +1,416 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <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_java = 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","none17", + "PRIVATE_USE","none19","DASH_PUNCTUATION","START_PUNCTUATION","END_PUNCTUATION", + "CONNECTOR_PUNCTUATION","OTHER_PUNCTUATION","MATH_SYMBOL","CURRENCY_SYMBOL", + "MODIFIER_SYMBOL","OTHER_SYMBOL"}; + + 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>java.lang.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>java.lang.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] == 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("Sysmbol :" + 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 localeIndex 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 000000000000..1905ca9a68ea --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XCollator.java @@ -0,0 +1,430 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <p> +* @see com.sun.star.i18n.XCollator +*/ +public class _XCollator extends MultiMethodTest { + public XCollator oObj = null; + private String[] alg = null ; + private int[] opt = 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()") ; + 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() ; + String res = "" ; + for (int i = 0; i < chars.length; i++) { + if (i != 0) res += "," ; + res += Integer.toHexString(chars[i]) ; + } + return res ; + } + +} + diff --git a/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java b/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java new file mode 100644 index 000000000000..8004a4eb97b0 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedCalendar.java @@ -0,0 +1,138 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +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.lang.XMultiServiceFactory; +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 + */ + public void before() { + Locale[] installed_locales = null; + XLocaleData locData = null; + try { + locData = (XLocaleData) UnoRuntime.queryInterface( + XLocaleData.class, + ((XMultiServiceFactory)tParam.getMSF()).createInstance( + "com.sun.star.i18n.LocaleData")); + } catch (com.sun.star.uno.Exception e) { + + } + 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 100755 index 000000000000..2443156b0baf --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedIndexEntrySupplier.java @@ -0,0 +1,336 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +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 algorithms = new HashMap(); + + 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; + boolean locResult = false; + + for (int i = 0; i < locales.length; i++) { + String[] algNames = oObj.getAlgorithmList(locales[i]); + algorithms.put(new Integer(i), algNames); + + locResult = algNames != null && 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 = (String[])algorithms.get(new Integer(j)); + for (int k=0;k<algs.length;k++) { + log.println("\t Algorythm :" + + 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 canidate 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 = (String[]) algorithms.get(new Integer(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; + } + +/* log.println("\tTrying to load 'dummy' algorithm"); + + boolean localres = !oObj.loadAlgorithm(locales[i], "dummy", + CollatorOptions.CollatorOptions_IGNORE_WIDTH); + + if (!localres) { + log.println("\t ... didn't work as expected - 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 oif unicode characters and the equivalent phonetics + * for the "getPhoneticCandidate" test. Euivalents are only usable for zh,CN locale. + */ + public static class UnicodeStringPair { + final static int valCount = 78; + static String[] sStringEquivalence = null; + static char[] iUnicodeEquivalence = null; + + static { + sStringEquivalence = new String[valCount]; + iUnicodeEquivalence = new char[valCount]; + 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 000000000000..caea6c06541a --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XExtendedTransliteration.java @@ -0,0 +1,95 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ +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 Locale loc = new Locale("ja", "JP", "") ; + private Locale loc = new Locale("en", "US", "") ; + + 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((java.io.PrintWriter)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 000000000000..903068b152aa --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XIndexEntrySupplier.java @@ -0,0 +1,107 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <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 localeIndex 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 000000000000..fcb1f4b266a5 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XLocaleData.java @@ -0,0 +1,497 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <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 puposes + 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; + Calendar[] calendar = new Calendar[1]; + + for (int i=0;i<7;i++) { + 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; + Currency[] currency = new Currency[1]; + + for (int i=0;i<7;i++) { + 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; + FormatElement[] format = new FormatElement[1]; + + for (int i=0;i<7;i++) { + 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; + Implementation[] impl = new Implementation[1]; + + for (int i=0;i<7;i++) { + 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; + String[] str = new String[1]; + + for (int i=0;i<7;i++) { + str = oObj.getSearchOptions(getLocale(i)); + for (int j=0;j<str.length;j++) { + if ((str[j].equals(""))) { + printit = true; + } + res &= (!str.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; + String[] str = new String[1]; + + for (int i=0;i<7;i++) { + str = oObj.getCollationOptions(getLocale(i)); + for (int j=0;j<str.length;j++) { + if ((str[j].equals(""))) { + printit = true; + } + res &= (!str.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; + String[] str = new String[1]; + + for (int i=0;i<7;i++) { + str = oObj.getTransliterations(getLocale(i)); + for (int j=0;j<str.length;j++) { + if ((str[j].equals(""))) { + printit = true; + } + res &= (!str.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; + String[] str = new String[1]; + + for (int i=0;i<7;i++) { + str = oObj.getReservedWord(getLocale(i)); + for (int j=0;j<str.length;j++) { + if ((str[j].equals(""))) { + printit = true; + } + res &= (!str.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 localeIndex 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++) { + //log.println("Day "+i+"(AbbrevName): "+calendar.Days[i].AbbrevName); + good &= (! calendar.Days[i].AbbrevName.equals("") ); + //log.println("Day "+i+"(FullName): "+calendar.Days[i].FullName); + good &= (! calendar.Days[i].FullName.equals("") ); + //log.println("Day "+i+"(ID): "+calendar.Days[i].ID); + good &= (! calendar.Days[i].ID.equals("") ); + } + for (int i=0;i<calendar.Months.length;i++) { + //log.println("Day "+i+"(AbbrevName): "+calendar.Months[i].AbbrevName); + good &= (! calendar.Months[i].AbbrevName.equals("") ); + //log.println("Day "+i+"(FullName): "+calendar.Months[i].FullName); + good &= (! calendar.Months[i].FullName.equals("") ); + //log.println("Day "+i+"(ID): "+calendar.Months[i].ID); + good &= (! calendar.Months[i].ID.equals("") ); + } + for (int i=0;i<calendar.Eras.length;i++) { + //log.println("Era "+i+"(AbbrevName): "+calendar.Eras[i].AbbrevName); + good &= (! calendar.Eras[i].AbbrevName.equals("") ); + //log.println("Era "+i+"(FullName): "+calendar.Eras[i].FullName); + good &= (! calendar.Eras[i].FullName.equals("") ); + //log.println("Era "+i+"(ID): "+calendar.Eras[i].ID); + good &= (! calendar.Eras[i].ID.equals("") ); + } + //log.println("Start of Week: "+calendar.StartOfWeek); + good &= (! calendar.StartOfWeek.equals("") ); + //log.println("MinimumNumberOfDaysForFirstWeek: "+calendar.MinimumNumberOfDaysForFirstWeek); + //log.println("Default: "+calendar.Default); + //log.println("Name: "+calendar.Name); + 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 000000000000..0566e27112c4 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XNumberFormatCode.java @@ -0,0 +1,163 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <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 a 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 localeIndex 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 000000000000..ea8502d31f29 --- /dev/null +++ b/qadevOOo/tests/java/ifc/i18n/_XTransliteration.java @@ -0,0 +1,456 @@ +/************************************************************************* + * + * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. + * + * Copyright 2000, 2010 Oracle and/or its affiliates. + * + * OpenOffice.org - a multi-platform office productivity suite + * + * This file is part of OpenOffice.org. + * + * OpenOffice.org is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License version 3 + * only, as published by the Free Software Foundation. + * + * OpenOffice.org is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU Lesser General Public License version 3 for more details + * (a copy is included in the LICENSE file that accompanied this code). + * + * You should have received a copy of the GNU Lesser General Public License + * version 3 along with OpenOffice.org. If not, see + * <http://www.openoffice.org/license.html> + * for a copy of the LGPLv3 License. + * + ************************************************************************/ + +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 compilant. <p> +* @see com.sun.star.i18n.XTransliteration +*/ +public class _XTransliteration extends MultiMethodTest { + + public XTransliteration oObj = null; + private String[] mod = null ; + private 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() { + 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 != null && + 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 with out 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 retruned + * 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 (java.lang.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 (java.lang.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 retruned + * 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 (java.lang.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 (java.lang.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 ; + } +} + |