diff options
Diffstat (limited to 'qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java')
| -rw-r--r-- | qadevOOo/tests/java/ifc/i18n/_XBreakIterator.java | 681 |
1 files changed, 681 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); + } + +} + |