1*b1cdbd2cSJim Jagielski /************************************************************** 2*b1cdbd2cSJim Jagielski * 3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one 4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file 5*b1cdbd2cSJim Jagielski * distributed with this work for additional information 6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file 7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the 8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance 9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at 10*b1cdbd2cSJim Jagielski * 11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0 12*b1cdbd2cSJim Jagielski * 13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing, 14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an 15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the 17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations 18*b1cdbd2cSJim Jagielski * under the License. 19*b1cdbd2cSJim Jagielski * 20*b1cdbd2cSJim Jagielski *************************************************************/ 21*b1cdbd2cSJim Jagielski 22*b1cdbd2cSJim Jagielski 23*b1cdbd2cSJim Jagielski 24*b1cdbd2cSJim Jagielski package ifc.i18n; 25*b1cdbd2cSJim Jagielski 26*b1cdbd2cSJim Jagielski import java.util.Vector; 27*b1cdbd2cSJim Jagielski 28*b1cdbd2cSJim Jagielski import lib.MultiMethodTest; 29*b1cdbd2cSJim Jagielski import lib.Status; 30*b1cdbd2cSJim Jagielski import lib.StatusException; 31*b1cdbd2cSJim Jagielski 32*b1cdbd2cSJim Jagielski import com.sun.star.i18n.Boundary; 33*b1cdbd2cSJim Jagielski import com.sun.star.i18n.LineBreakHyphenationOptions; 34*b1cdbd2cSJim Jagielski import com.sun.star.i18n.LineBreakResults; 35*b1cdbd2cSJim Jagielski import com.sun.star.i18n.LineBreakUserOptions; 36*b1cdbd2cSJim Jagielski import com.sun.star.i18n.ScriptType; 37*b1cdbd2cSJim Jagielski import com.sun.star.i18n.WordType; 38*b1cdbd2cSJim Jagielski import com.sun.star.i18n.XBreakIterator; 39*b1cdbd2cSJim Jagielski import com.sun.star.lang.Locale; 40*b1cdbd2cSJim Jagielski 41*b1cdbd2cSJim Jagielski /** 42*b1cdbd2cSJim Jagielski * Testing <code>com.sun.star.i18n.XBreakIterator</code> 43*b1cdbd2cSJim Jagielski * interface methods : 44*b1cdbd2cSJim Jagielski * <ul> 45*b1cdbd2cSJim Jagielski * <li><code> nextCharacters()</code></li> 46*b1cdbd2cSJim Jagielski * <li><code> previousCharacters()</code></li> 47*b1cdbd2cSJim Jagielski * <li><code> nextWord()</code></li> 48*b1cdbd2cSJim Jagielski * <li><code> previousWord()</code></li> 49*b1cdbd2cSJim Jagielski * <li><code> getWordBoundary()</code></li> 50*b1cdbd2cSJim Jagielski * <li><code> getWordType()</code></li> 51*b1cdbd2cSJim Jagielski * <li><code> isBeginWord()</code></li> 52*b1cdbd2cSJim Jagielski * <li><code> isEndWord()</code></li> 53*b1cdbd2cSJim Jagielski * <li><code> beginOfSentence()</code></li> 54*b1cdbd2cSJim Jagielski * <li><code> endOfSentence()</code></li> 55*b1cdbd2cSJim Jagielski * <li><code> getLineBreak()</code></li> 56*b1cdbd2cSJim Jagielski * <li><code> beginOfScript()</code></li> 57*b1cdbd2cSJim Jagielski * <li><code> endOfScript()</code></li> 58*b1cdbd2cSJim Jagielski * <li><code> nextScript()</code></li> 59*b1cdbd2cSJim Jagielski * <li><code> previousScript()</code></li> 60*b1cdbd2cSJim Jagielski * <li><code> getScriptType()</code></li> 61*b1cdbd2cSJim Jagielski * <li><code> beginOfCharBlock()</code></li> 62*b1cdbd2cSJim Jagielski * <li><code> endOfCharBlock()</code></li> 63*b1cdbd2cSJim Jagielski * <li><code> nextCharBlock()</code></li> 64*b1cdbd2cSJim Jagielski * <li><code> previousCharBlock()</code></li> 65*b1cdbd2cSJim Jagielski * </ul> <p> 66*b1cdbd2cSJim Jagielski * This test needs the following object relations : 67*b1cdbd2cSJim Jagielski * <ul> 68*b1cdbd2cSJim Jagielski * <li> <code>'Locale'</code> 69*b1cdbd2cSJim Jagielski * (of type <code>com.sun.star.lang.Locale</code>): 70*b1cdbd2cSJim Jagielski * this locale is used as locale argument for tested methods. 71*b1cdbd2cSJim Jagielski * </li> 72*b1cdbd2cSJim Jagielski * <li> <code>'UnicodeString'</code> 73*b1cdbd2cSJim Jagielski * (of type <code>String</code>): Unicode string which is passed 74*b1cdbd2cSJim Jagielski * to methods except 'CharacterBlock' methods. 75*b1cdbd2cSJim Jagielski * </li> 76*b1cdbd2cSJim Jagielski * <ul> <p> 77*b1cdbd2cSJim Jagielski * @see com.sun.star.i18n.XBreakIterator 78*b1cdbd2cSJim Jagielski */ 79*b1cdbd2cSJim Jagielski public class _XBreakIterator extends MultiMethodTest { 80*b1cdbd2cSJim Jagielski 81*b1cdbd2cSJim Jagielski public XBreakIterator oObj = null; 82*b1cdbd2cSJim Jagielski 83*b1cdbd2cSJim Jagielski Locale locale = null; 84*b1cdbd2cSJim Jagielski String UnicodeString = null; 85*b1cdbd2cSJim Jagielski 86*b1cdbd2cSJim Jagielski short wordType = WordType.ANYWORD_IGNOREWHITESPACES; 87*b1cdbd2cSJim Jagielski 88*b1cdbd2cSJim Jagielski /** 89*b1cdbd2cSJim Jagielski * Retrieves object relations. 90*b1cdbd2cSJim Jagielski * @throws StatusException If one of relations not found. 91*b1cdbd2cSJim Jagielski */ before()92*b1cdbd2cSJim Jagielski protected void before() { 93*b1cdbd2cSJim Jagielski locale = (Locale)tEnv.getObjRelation("Locale"); 94*b1cdbd2cSJim Jagielski if (locale == null) { 95*b1cdbd2cSJim Jagielski throw new StatusException 96*b1cdbd2cSJim Jagielski (Status.failed("Relation 'Locale' not found")) ; 97*b1cdbd2cSJim Jagielski } 98*b1cdbd2cSJim Jagielski 99*b1cdbd2cSJim Jagielski UnicodeString = (String)tEnv.getObjRelation("UnicodeString"); 100*b1cdbd2cSJim Jagielski if (UnicodeString == null) { 101*b1cdbd2cSJim Jagielski throw new StatusException(Status.failed 102*b1cdbd2cSJim Jagielski ("Relation 'UnicodeString' not found")) ; 103*b1cdbd2cSJim Jagielski } 104*b1cdbd2cSJim Jagielski } 105*b1cdbd2cSJim Jagielski 106*b1cdbd2cSJim Jagielski /** 107*b1cdbd2cSJim Jagielski * Compares returned next character positions with expected values. <p> 108*b1cdbd2cSJim Jagielski * 109*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if position after travel and traveled length 110*b1cdbd2cSJim Jagielski * has expected values. 111*b1cdbd2cSJim Jagielski */ _nextCharacters()112*b1cdbd2cSJim Jagielski public void _nextCharacters() { 113*b1cdbd2cSJim Jagielski short nCharacterIteratorMode = 114*b1cdbd2cSJim Jagielski com.sun.star.i18n.CharacterIteratorMode.SKIPCHARACTER; 115*b1cdbd2cSJim Jagielski 116*b1cdbd2cSJim Jagielski int strLength = UnicodeString.length(); 117*b1cdbd2cSJim Jagielski 118*b1cdbd2cSJim Jagielski //Start from position : Travel ... chars : 119*b1cdbd2cSJim Jagielski // Actual position after : How many chars traveled 120*b1cdbd2cSJim Jagielski int[][] nextCharacters = { 121*b1cdbd2cSJim Jagielski { 1, 5000, strLength , strLength - 1 }, 122*b1cdbd2cSJim Jagielski { 10, 6, 16, 6}}; 123*b1cdbd2cSJim Jagielski 124*b1cdbd2cSJim Jagielski boolean bRes = true; 125*b1cdbd2cSJim Jagielski 126*b1cdbd2cSJim Jagielski for(int i = 0; i < nextCharacters.length; i++) { 127*b1cdbd2cSJim Jagielski int[] lDone = new int[1]; 128*b1cdbd2cSJim Jagielski long lRes = oObj.nextCharacters(UnicodeString, nextCharacters[i][0], 129*b1cdbd2cSJim Jagielski locale, nCharacterIteratorMode, nextCharacters[i][1], lDone); 130*b1cdbd2cSJim Jagielski log.println("Expected result is: lRes = " + nextCharacters[i][2] + 131*b1cdbd2cSJim Jagielski "; lDone = " + nextCharacters[i][3] ); 132*b1cdbd2cSJim Jagielski log.println("Actual result is: lRes = " + lRes + 133*b1cdbd2cSJim Jagielski "; lDone = " + lDone[0] ); 134*b1cdbd2cSJim Jagielski 135*b1cdbd2cSJim Jagielski bRes = bRes && lRes == nextCharacters[i][2]; 136*b1cdbd2cSJim Jagielski bRes = bRes && lDone[0] == nextCharacters[i][3]; 137*b1cdbd2cSJim Jagielski } 138*b1cdbd2cSJim Jagielski 139*b1cdbd2cSJim Jagielski tRes.tested("nextCharacters()", bRes); 140*b1cdbd2cSJim Jagielski } 141*b1cdbd2cSJim Jagielski 142*b1cdbd2cSJim Jagielski /** 143*b1cdbd2cSJim Jagielski * Compares returned previous character positions with expected values. <p> 144*b1cdbd2cSJim Jagielski * 145*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if position after travel and traveled length 146*b1cdbd2cSJim Jagielski * has expected values. 147*b1cdbd2cSJim Jagielski */ _previousCharacters()148*b1cdbd2cSJim Jagielski public void _previousCharacters() { 149*b1cdbd2cSJim Jagielski short nCharacterIteratorMode = 150*b1cdbd2cSJim Jagielski com.sun.star.i18n.CharacterIteratorMode.SKIPCHARACTER; 151*b1cdbd2cSJim Jagielski 152*b1cdbd2cSJim Jagielski 153*b1cdbd2cSJim Jagielski //Start from position : Travel ... chars : Actual position after : 154*b1cdbd2cSJim Jagielski //How many chars traveled 155*b1cdbd2cSJim Jagielski int[][] previousCharacters = { 156*b1cdbd2cSJim Jagielski {5, 5000, 0, 5}, 157*b1cdbd2cSJim Jagielski {10, 6, 4, 6}}; 158*b1cdbd2cSJim Jagielski 159*b1cdbd2cSJim Jagielski boolean bRes = true; 160*b1cdbd2cSJim Jagielski for(int i = 0; i < previousCharacters.length; i++) { 161*b1cdbd2cSJim Jagielski int[] lDone = new int[1]; 162*b1cdbd2cSJim Jagielski int lRes = oObj.previousCharacters(UnicodeString, 163*b1cdbd2cSJim Jagielski previousCharacters[i][0], 164*b1cdbd2cSJim Jagielski locale, nCharacterIteratorMode, 165*b1cdbd2cSJim Jagielski previousCharacters[i][1], lDone); 166*b1cdbd2cSJim Jagielski log.println("Expected result is: lRes = " + previousCharacters[i][2] 167*b1cdbd2cSJim Jagielski + "; lDone = " + previousCharacters[i][3] ); 168*b1cdbd2cSJim Jagielski log.println("Actual result is: lRes = " + lRes 169*b1cdbd2cSJim Jagielski + "; lDone = " + lDone[0]); 170*b1cdbd2cSJim Jagielski 171*b1cdbd2cSJim Jagielski bRes = bRes && lRes == previousCharacters[i][2]; 172*b1cdbd2cSJim Jagielski bRes = bRes && lDone[0] == previousCharacters[i][3]; 173*b1cdbd2cSJim Jagielski } 174*b1cdbd2cSJim Jagielski 175*b1cdbd2cSJim Jagielski tRes.tested("previousCharacters()", bRes); 176*b1cdbd2cSJim Jagielski } 177*b1cdbd2cSJim Jagielski 178*b1cdbd2cSJim Jagielski Vector vBounds = new Vector(); 179*b1cdbd2cSJim Jagielski 180*b1cdbd2cSJim Jagielski /** 181*b1cdbd2cSJim Jagielski * Saves bounds of all returned words for the future tests. <p> 182*b1cdbd2cSJim Jagielski * Has <b>OK</b> status. 183*b1cdbd2cSJim Jagielski */ _nextWord()184*b1cdbd2cSJim Jagielski public void _nextWord() { 185*b1cdbd2cSJim Jagielski int i = 0; 186*b1cdbd2cSJim Jagielski 187*b1cdbd2cSJim Jagielski while( i < UnicodeString.length() - 1 ) { 188*b1cdbd2cSJim Jagielski Boundary bounds = oObj.nextWord 189*b1cdbd2cSJim Jagielski (UnicodeString, i, locale, wordType); 190*b1cdbd2cSJim Jagielski if (bounds.endPos - bounds.startPos > 3) { 191*b1cdbd2cSJim Jagielski vBounds.add( bounds ); 192*b1cdbd2cSJim Jagielski log.println("Word " + vBounds.size() + "(" 193*b1cdbd2cSJim Jagielski + bounds.startPos + "," + bounds.endPos + "): '" + 194*b1cdbd2cSJim Jagielski UnicodeString.substring(bounds.startPos, 195*b1cdbd2cSJim Jagielski bounds.endPos) + "'"); 196*b1cdbd2cSJim Jagielski } 197*b1cdbd2cSJim Jagielski i = bounds.endPos - 1; 198*b1cdbd2cSJim Jagielski } 199*b1cdbd2cSJim Jagielski log.println("In text there are " + vBounds.size() 200*b1cdbd2cSJim Jagielski + " words, if count from left to right"); 201*b1cdbd2cSJim Jagielski tRes.tested("nextWord()", true); 202*b1cdbd2cSJim Jagielski } 203*b1cdbd2cSJim Jagielski 204*b1cdbd2cSJim Jagielski /** 205*b1cdbd2cSJim Jagielski * Compares number of word bounds with number of word bounds saved 206*b1cdbd2cSJim Jagielski * by the method _nextWord().<p> 207*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if number of word bounds are equal. 208*b1cdbd2cSJim Jagielski */ _previousWord()209*b1cdbd2cSJim Jagielski public void _previousWord() { 210*b1cdbd2cSJim Jagielski requiredMethod("nextWord()"); 211*b1cdbd2cSJim Jagielski 212*b1cdbd2cSJim Jagielski int i = UnicodeString.length() - 1; 213*b1cdbd2cSJim Jagielski Vector vPrevBounds = new Vector(); 214*b1cdbd2cSJim Jagielski while( i > 0 ) { 215*b1cdbd2cSJim Jagielski Boundary bounds = 216*b1cdbd2cSJim Jagielski oObj.previousWord(UnicodeString, i, locale, wordType); 217*b1cdbd2cSJim Jagielski if (bounds.endPos - bounds.startPos > 3) { 218*b1cdbd2cSJim Jagielski vPrevBounds.add( bounds ); 219*b1cdbd2cSJim Jagielski log.println("Word " + vPrevBounds.size() + "(" 220*b1cdbd2cSJim Jagielski + bounds.startPos + "," + bounds.endPos + "): '" 221*b1cdbd2cSJim Jagielski + UnicodeString.substring(bounds.startPos, bounds.endPos) 222*b1cdbd2cSJim Jagielski + "'"); 223*b1cdbd2cSJim Jagielski } 224*b1cdbd2cSJim Jagielski i = bounds.startPos; 225*b1cdbd2cSJim Jagielski } 226*b1cdbd2cSJim Jagielski log.println("In text there are " + vPrevBounds.size() 227*b1cdbd2cSJim Jagielski + " words, if count from right to left"); 228*b1cdbd2cSJim Jagielski tRes.tested("previousWord()", vPrevBounds.size() == vBounds.size() ); 229*b1cdbd2cSJim Jagielski } 230*b1cdbd2cSJim Jagielski 231*b1cdbd2cSJim Jagielski /** 232*b1cdbd2cSJim Jagielski * For every word in array obtained by <code>nextWord</code> method test 233*b1cdbd2cSJim Jagielski * computes bounds of the word, passing its internal character position.<p> 234*b1cdbd2cSJim Jagielski * 235*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if bounds calculated by <code>getWordBoundary()</code> 236*b1cdbd2cSJim Jagielski * method are the same as bounds obtained by <code>nextWord</code> method. 237*b1cdbd2cSJim Jagielski */ _getWordBoundary()238*b1cdbd2cSJim Jagielski public void _getWordBoundary() { 239*b1cdbd2cSJim Jagielski requiredMethod("nextWord()"); 240*b1cdbd2cSJim Jagielski 241*b1cdbd2cSJim Jagielski boolean bRes = true; 242*b1cdbd2cSJim Jagielski 243*b1cdbd2cSJim Jagielski for(int i = 0; i < vBounds.size(); i++) { 244*b1cdbd2cSJim Jagielski // calculate middle of the word 245*b1cdbd2cSJim Jagielski Boundary iBounds = (Boundary)vBounds.get(i); 246*b1cdbd2cSJim Jagielski int iPos = (iBounds.endPos - iBounds.startPos) / 2 247*b1cdbd2cSJim Jagielski + iBounds.startPos; 248*b1cdbd2cSJim Jagielski Boundary bounds = oObj.getWordBoundary(UnicodeString, iPos, 249*b1cdbd2cSJim Jagielski locale, wordType, true); 250*b1cdbd2cSJim Jagielski log.println("Expected result is: startPos = " + iBounds.startPos + 251*b1cdbd2cSJim Jagielski "; endPos = " + iBounds.endPos); 252*b1cdbd2cSJim Jagielski log.println("Actual result is: startPos = " + bounds.startPos 253*b1cdbd2cSJim Jagielski + "; endPos = " + bounds.endPos + " Word is: '" 254*b1cdbd2cSJim Jagielski + UnicodeString.substring(bounds.startPos, bounds.endPos) + "'"); 255*b1cdbd2cSJim Jagielski 256*b1cdbd2cSJim Jagielski bRes = bRes && iBounds.startPos == bounds.startPos; 257*b1cdbd2cSJim Jagielski bRes = bRes && iBounds.endPos == bounds.endPos; 258*b1cdbd2cSJim Jagielski } 259*b1cdbd2cSJim Jagielski 260*b1cdbd2cSJim Jagielski tRes.tested("getWordBoundary()", bRes); 261*b1cdbd2cSJim Jagielski } 262*b1cdbd2cSJim Jagielski 263*b1cdbd2cSJim Jagielski /** 264*b1cdbd2cSJim Jagielski * For every word in array obtained by <code>nextWord</code> method test 265*b1cdbd2cSJim Jagielski * get its type, passing its internal character position.<p> 266*b1cdbd2cSJim Jagielski * 267*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if every word has type <code>WordType.ANY_WORD</code> 268*b1cdbd2cSJim Jagielski */ _getWordType()269*b1cdbd2cSJim Jagielski public void _getWordType() { 270*b1cdbd2cSJim Jagielski requiredMethod("nextWord()"); 271*b1cdbd2cSJim Jagielski 272*b1cdbd2cSJim Jagielski boolean bRes = true; 273*b1cdbd2cSJim Jagielski 274*b1cdbd2cSJim Jagielski for(int i = 0; i < vBounds.size(); i++) { 275*b1cdbd2cSJim Jagielski // calculate middle of the word 276*b1cdbd2cSJim Jagielski Boundary iBounds = (Boundary)vBounds.get(i); 277*b1cdbd2cSJim Jagielski int iPos = (iBounds.endPos - iBounds.startPos) / 2 278*b1cdbd2cSJim Jagielski + iBounds.startPos; 279*b1cdbd2cSJim Jagielski 280*b1cdbd2cSJim Jagielski short type = oObj.getWordType(UnicodeString, iPos, locale); 281*b1cdbd2cSJim Jagielski 282*b1cdbd2cSJim Jagielski bRes = bRes && type == WordType.ANY_WORD; 283*b1cdbd2cSJim Jagielski } 284*b1cdbd2cSJim Jagielski 285*b1cdbd2cSJim Jagielski tRes.tested("getWordType()", bRes); 286*b1cdbd2cSJim Jagielski } 287*b1cdbd2cSJim Jagielski 288*b1cdbd2cSJim Jagielski /** 289*b1cdbd2cSJim Jagielski * For every word in array obtained by <code>nextWord</code> method test 290*b1cdbd2cSJim Jagielski * tries to determine if the character at a position starts a word. 291*b1cdbd2cSJim Jagielski * First word starting position is passed, then internal character 292*b1cdbd2cSJim Jagielski * position is passed. <p> 293*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if in the first case <code>true</code> 294*b1cdbd2cSJim Jagielski * returned and in the second - <code>false</code> for every word. 295*b1cdbd2cSJim Jagielski */ _isBeginWord()296*b1cdbd2cSJim Jagielski public void _isBeginWord() { 297*b1cdbd2cSJim Jagielski requiredMethod("nextWord()"); 298*b1cdbd2cSJim Jagielski 299*b1cdbd2cSJim Jagielski boolean bRes = true; 300*b1cdbd2cSJim Jagielski 301*b1cdbd2cSJim Jagielski for(int i = 0; i < vBounds.size(); i++) { 302*b1cdbd2cSJim Jagielski Boundary iBounds = (Boundary)vBounds.get(i); 303*b1cdbd2cSJim Jagielski boolean isBegin = oObj.isBeginWord(UnicodeString, iBounds.startPos, 304*b1cdbd2cSJim Jagielski locale, WordType.ANY_WORD); 305*b1cdbd2cSJim Jagielski bRes = bRes && isBegin; 306*b1cdbd2cSJim Jagielski boolean isNotBegin = !oObj.isBeginWord(UnicodeString, 307*b1cdbd2cSJim Jagielski iBounds.startPos + 1, locale, WordType.ANY_WORD); 308*b1cdbd2cSJim Jagielski bRes = bRes && isNotBegin; 309*b1cdbd2cSJim Jagielski 310*b1cdbd2cSJim Jagielski log.println("At position + " + iBounds.startPos 311*b1cdbd2cSJim Jagielski + " isBeginWord? " + isBegin); 312*b1cdbd2cSJim Jagielski log.println("At position + " + (iBounds.startPos + 1) 313*b1cdbd2cSJim Jagielski + " isBeginWord? " + !isNotBegin); 314*b1cdbd2cSJim Jagielski } 315*b1cdbd2cSJim Jagielski 316*b1cdbd2cSJim Jagielski tRes.tested("isBeginWord()", bRes); 317*b1cdbd2cSJim Jagielski } 318*b1cdbd2cSJim Jagielski 319*b1cdbd2cSJim Jagielski /** 320*b1cdbd2cSJim Jagielski * For every word in array obtained by <code>nextWord</code> method test 321*b1cdbd2cSJim Jagielski * tries to determine if the character at a position ends a word. 322*b1cdbd2cSJim Jagielski * First word ending position is passed, then internal character 323*b1cdbd2cSJim Jagielski * position is passed. <p> 324*b1cdbd2cSJim Jagielski * 325*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if in the first case <code>true</code> 326*b1cdbd2cSJim Jagielski * returned and in the second - <code>false</code> for every word. 327*b1cdbd2cSJim Jagielski */ _isEndWord()328*b1cdbd2cSJim Jagielski public void _isEndWord() { 329*b1cdbd2cSJim Jagielski requiredMethod("nextWord()"); 330*b1cdbd2cSJim Jagielski 331*b1cdbd2cSJim Jagielski boolean bRes = true; 332*b1cdbd2cSJim Jagielski 333*b1cdbd2cSJim Jagielski for(int i = 0; i < vBounds.size(); i++) { 334*b1cdbd2cSJim Jagielski Boundary iBounds = (Boundary)vBounds.get(i); 335*b1cdbd2cSJim Jagielski boolean isEnd = oObj.isEndWord(UnicodeString, iBounds.endPos, 336*b1cdbd2cSJim Jagielski locale, WordType.ANY_WORD); 337*b1cdbd2cSJim Jagielski bRes = bRes && isEnd; 338*b1cdbd2cSJim Jagielski boolean isNotEnd = !oObj.isEndWord(UnicodeString, 339*b1cdbd2cSJim Jagielski iBounds.endPos - 1, locale, WordType.ANY_WORD); 340*b1cdbd2cSJim Jagielski bRes = bRes && isNotEnd; 341*b1cdbd2cSJim Jagielski 342*b1cdbd2cSJim Jagielski log.println("At position + " + iBounds.endPos 343*b1cdbd2cSJim Jagielski + " isEndWord? " + isEnd); 344*b1cdbd2cSJim Jagielski log.println("At position + " + (iBounds.endPos - 1) 345*b1cdbd2cSJim Jagielski + " isEndWord? " + !isNotEnd); 346*b1cdbd2cSJim Jagielski } 347*b1cdbd2cSJim Jagielski 348*b1cdbd2cSJim Jagielski tRes.tested("isEndWord()", bRes); 349*b1cdbd2cSJim Jagielski } 350*b1cdbd2cSJim Jagielski 351*b1cdbd2cSJim Jagielski Vector vSentenceStart = new Vector(); 352*b1cdbd2cSJim Jagielski /** 353*b1cdbd2cSJim Jagielski * Tries to find all sentences starting positions passing every character 354*b1cdbd2cSJim Jagielski * as position parameter and stores them. Then tries to pass invalid 355*b1cdbd2cSJim Jagielski * position parameters. 356*b1cdbd2cSJim Jagielski * 357*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if -1 is returned for wrong position arguments. 358*b1cdbd2cSJim Jagielski */ _beginOfSentence()359*b1cdbd2cSJim Jagielski public void _beginOfSentence() { 360*b1cdbd2cSJim Jagielski int iPos = 0; 361*b1cdbd2cSJim Jagielski while( iPos < UnicodeString.length() ) { 362*b1cdbd2cSJim Jagielski Integer start = new Integer( oObj.beginOfSentence(UnicodeString, 363*b1cdbd2cSJim Jagielski iPos, locale) ); 364*b1cdbd2cSJim Jagielski if (start.intValue() >= 0 && !vSentenceStart.contains(start) ) { 365*b1cdbd2cSJim Jagielski vSentenceStart.add( start ); 366*b1cdbd2cSJim Jagielski log.println("Sentence " + vSentenceStart.size() 367*b1cdbd2cSJim Jagielski + " : start from position " + start); 368*b1cdbd2cSJim Jagielski } 369*b1cdbd2cSJim Jagielski iPos++; 370*b1cdbd2cSJim Jagielski } 371*b1cdbd2cSJim Jagielski 372*b1cdbd2cSJim Jagielski //test for invalid nStartPosition 373*b1cdbd2cSJim Jagielski boolean bRes = oObj.beginOfSentence(UnicodeString, -10, locale) == -1; 374*b1cdbd2cSJim Jagielski bRes &= oObj.beginOfSentence(UnicodeString, 375*b1cdbd2cSJim Jagielski UnicodeString.length() + 1, locale) == -1; 376*b1cdbd2cSJim Jagielski 377*b1cdbd2cSJim Jagielski if (!bRes) { 378*b1cdbd2cSJim Jagielski log.println("When invalid position, returned value isn't equal to -1"); 379*b1cdbd2cSJim Jagielski } 380*b1cdbd2cSJim Jagielski 381*b1cdbd2cSJim Jagielski tRes.tested("beginOfSentence()", bRes); 382*b1cdbd2cSJim Jagielski } 383*b1cdbd2cSJim Jagielski 384*b1cdbd2cSJim Jagielski /** 385*b1cdbd2cSJim Jagielski * For every sentence starting position found in 386*b1cdbd2cSJim Jagielski * <code>beginOfSentence()</code> test tries to compute end 387*b1cdbd2cSJim Jagielski * position of a sentence and checks that the end position is 388*b1cdbd2cSJim Jagielski * greater than starting. 389*b1cdbd2cSJim Jagielski * Then wrong position arguments are passed. 390*b1cdbd2cSJim Jagielski * 391*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the end position of every sentence 392*b1cdbd2cSJim Jagielski * greater than starting and -1 returned for invalid arguments. 393*b1cdbd2cSJim Jagielski */ _endOfSentence()394*b1cdbd2cSJim Jagielski public void _endOfSentence() { 395*b1cdbd2cSJim Jagielski boolean bRes = true; 396*b1cdbd2cSJim Jagielski for(int i = 0; i < vSentenceStart.size(); i++) { 397*b1cdbd2cSJim Jagielski int start = ((Integer)vSentenceStart.get(i)).intValue(); 398*b1cdbd2cSJim Jagielski int end = oObj.endOfSentence(UnicodeString, start, locale); 399*b1cdbd2cSJim Jagielski bRes &= end > start; 400*b1cdbd2cSJim Jagielski log.println("Sentence " + i + " range is [" + start + ", " 401*b1cdbd2cSJim Jagielski + end + "]"); 402*b1cdbd2cSJim Jagielski } 403*b1cdbd2cSJim Jagielski 404*b1cdbd2cSJim Jagielski //test for invalid nStartPosition 405*b1cdbd2cSJim Jagielski boolean bInvRes = oObj.endOfSentence(UnicodeString, -10, locale) == -1; 406*b1cdbd2cSJim Jagielski bInvRes &= oObj.endOfSentence(UnicodeString, 407*b1cdbd2cSJim Jagielski UnicodeString.length() + 1, locale) == -1; 408*b1cdbd2cSJim Jagielski 409*b1cdbd2cSJim Jagielski if (!bInvRes) { 410*b1cdbd2cSJim Jagielski log.println("When invalid position, returned value isn't equal to -1"); 411*b1cdbd2cSJim Jagielski } 412*b1cdbd2cSJim Jagielski 413*b1cdbd2cSJim Jagielski tRes.tested("endOfSentence()", bRes && bInvRes); 414*b1cdbd2cSJim Jagielski } 415*b1cdbd2cSJim Jagielski 416*b1cdbd2cSJim Jagielski /** 417*b1cdbd2cSJim Jagielski * Tries to break a string in position other than 0 iterating characters 418*b1cdbd2cSJim Jagielski * from the string beginning (Hyphenation is not used for a while). <p> 419*b1cdbd2cSJim Jagielski * 420*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if non-zero break position was found and it is 421*b1cdbd2cSJim Jagielski * less or equal than position we trying to break. 422*b1cdbd2cSJim Jagielski */ _getLineBreak()423*b1cdbd2cSJim Jagielski public void _getLineBreak() { 424*b1cdbd2cSJim Jagielski boolean bRes = true; 425*b1cdbd2cSJim Jagielski LineBreakResults lineBreakResults; 426*b1cdbd2cSJim Jagielski LineBreakHyphenationOptions lineBreakHyphenationOptions = 427*b1cdbd2cSJim Jagielski new LineBreakHyphenationOptions(); 428*b1cdbd2cSJim Jagielski LineBreakUserOptions lineBreakUserOptions = new LineBreakUserOptions(); 429*b1cdbd2cSJim Jagielski 430*b1cdbd2cSJim Jagielski lineBreakUserOptions.applyForbiddenRules = false; 431*b1cdbd2cSJim Jagielski lineBreakUserOptions.allowHyphenateEnglish = false; 432*b1cdbd2cSJim Jagielski 433*b1cdbd2cSJim Jagielski int breakPos = 0; 434*b1cdbd2cSJim Jagielski int pos = 0; 435*b1cdbd2cSJim Jagielski 436*b1cdbd2cSJim Jagielski while(breakPos == 0 && pos < UnicodeString.length() ) { 437*b1cdbd2cSJim Jagielski lineBreakResults = oObj.getLineBreak(UnicodeString, pos, 438*b1cdbd2cSJim Jagielski locale, 0, lineBreakHyphenationOptions, lineBreakUserOptions); 439*b1cdbd2cSJim Jagielski breakPos = lineBreakResults.breakIndex; 440*b1cdbd2cSJim Jagielski pos++; 441*b1cdbd2cSJim Jagielski } 442*b1cdbd2cSJim Jagielski 443*b1cdbd2cSJim Jagielski // finally the position of break must be found in the middle and 444*b1cdbd2cSJim Jagielski // it must be before the break position specified 445*b1cdbd2cSJim Jagielski bRes = breakPos <= pos && breakPos > 0; 446*b1cdbd2cSJim Jagielski 447*b1cdbd2cSJim Jagielski if (!bRes) { 448*b1cdbd2cSJim Jagielski log.println("The last position was: " + pos 449*b1cdbd2cSJim Jagielski + ", and the break position was: " + breakPos); 450*b1cdbd2cSJim Jagielski } 451*b1cdbd2cSJim Jagielski 452*b1cdbd2cSJim Jagielski tRes.tested("getLineBreak()", bRes); 453*b1cdbd2cSJim Jagielski } 454*b1cdbd2cSJim Jagielski 455*b1cdbd2cSJim Jagielski // Asian type script 456*b1cdbd2cSJim Jagielski private static String katakana = new String(new char[] {0x30A1, 0x30A2}) ; 457*b1cdbd2cSJim Jagielski // Weak type script 458*b1cdbd2cSJim Jagielski private static String arrows = new String(new char[] {0x2190, 0x2191}) ; 459*b1cdbd2cSJim Jagielski // Complex type script 460*b1cdbd2cSJim Jagielski private static String arabic = new String(new char[] {0x0641, 0x0642}) ; 461*b1cdbd2cSJim Jagielski 462*b1cdbd2cSJim Jagielski /** 463*b1cdbd2cSJim Jagielski * Tries to find the begining of the nearest script specified 464*b1cdbd2cSJim Jagielski * relatively to position passed. <p> 465*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the starting position of script is returned. 466*b1cdbd2cSJim Jagielski */ _beginOfScript()467*b1cdbd2cSJim Jagielski public void _beginOfScript() { 468*b1cdbd2cSJim Jagielski String multiScript = "ab" + katakana ; 469*b1cdbd2cSJim Jagielski 470*b1cdbd2cSJim Jagielski int pos = oObj.beginOfScript(multiScript, 3, ScriptType.ASIAN) ; 471*b1cdbd2cSJim Jagielski 472*b1cdbd2cSJim Jagielski log.println("Position = " + pos) ; 473*b1cdbd2cSJim Jagielski 474*b1cdbd2cSJim Jagielski tRes.tested("beginOfScript()", pos == 2) ; 475*b1cdbd2cSJim Jagielski } 476*b1cdbd2cSJim Jagielski 477*b1cdbd2cSJim Jagielski /** 478*b1cdbd2cSJim Jagielski * Tries to find the end of the nearest script specified 479*b1cdbd2cSJim Jagielski * relatively to position passed. <p> 480*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the end position of script is returned. 481*b1cdbd2cSJim Jagielski */ _endOfScript()482*b1cdbd2cSJim Jagielski public void _endOfScript() { 483*b1cdbd2cSJim Jagielski String multiScript = "ab" + katakana + "cd" ; 484*b1cdbd2cSJim Jagielski 485*b1cdbd2cSJim Jagielski int pos = oObj.endOfScript(multiScript, 2, ScriptType.ASIAN) ; 486*b1cdbd2cSJim Jagielski 487*b1cdbd2cSJim Jagielski log.println("Position = " + pos) ; 488*b1cdbd2cSJim Jagielski 489*b1cdbd2cSJim Jagielski tRes.tested("endOfScript()", pos == 4) ; 490*b1cdbd2cSJim Jagielski } 491*b1cdbd2cSJim Jagielski 492*b1cdbd2cSJim Jagielski /** 493*b1cdbd2cSJim Jagielski * Tries to find the next script starting position specified 494*b1cdbd2cSJim Jagielski * relatively to position passed. <p> 495*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the appropriate position is returned. 496*b1cdbd2cSJim Jagielski */ _nextScript()497*b1cdbd2cSJim Jagielski public void _nextScript() { 498*b1cdbd2cSJim Jagielski String multiScript = "ab" + katakana + "cd" ; 499*b1cdbd2cSJim Jagielski 500*b1cdbd2cSJim Jagielski int pos = oObj.nextScript(multiScript, 0, ScriptType.LATIN) ; 501*b1cdbd2cSJim Jagielski 502*b1cdbd2cSJim Jagielski log.println("Position = " + pos) ; 503*b1cdbd2cSJim Jagielski 504*b1cdbd2cSJim Jagielski tRes.tested("nextScript()", pos == 4) ; 505*b1cdbd2cSJim Jagielski } 506*b1cdbd2cSJim Jagielski 507*b1cdbd2cSJim Jagielski /** 508*b1cdbd2cSJim Jagielski * Tries to find the previous script starting position specified 509*b1cdbd2cSJim Jagielski * relatively to position passed. <p> 510*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the appropriate position is returned. 511*b1cdbd2cSJim Jagielski */ _previousScript()512*b1cdbd2cSJim Jagielski public void _previousScript() { 513*b1cdbd2cSJim Jagielski String multiScript = "ab" + katakana + "cd" ; 514*b1cdbd2cSJim Jagielski 515*b1cdbd2cSJim Jagielski int pos = oObj.previousScript(multiScript, 5, ScriptType.ASIAN) ; 516*b1cdbd2cSJim Jagielski 517*b1cdbd2cSJim Jagielski log.println("Position = " + pos) ; 518*b1cdbd2cSJim Jagielski 519*b1cdbd2cSJim Jagielski tRes.tested("previousScript()", pos == 2) ; 520*b1cdbd2cSJim Jagielski } 521*b1cdbd2cSJim Jagielski 522*b1cdbd2cSJim Jagielski /** 523*b1cdbd2cSJim Jagielski * Tries to determine script type (of all four types). <p> 524*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if <code>LATIN</code> type returned 525*b1cdbd2cSJim Jagielski * for ACSII character, <code>ASIAN</code> for Katakana Unicode 526*b1cdbd2cSJim Jagielski * codepoints, <code>COMPLEX</code> for Arabic Unicode 527*b1cdbd2cSJim Jagielski * codepoints and <code>WEAK</code> for codepoints from Arrows 528*b1cdbd2cSJim Jagielski * Unicode block. 529*b1cdbd2cSJim Jagielski */ _getScriptType()530*b1cdbd2cSJim Jagielski public void _getScriptType() { 531*b1cdbd2cSJim Jagielski boolean res = true ; 532*b1cdbd2cSJim Jagielski 533*b1cdbd2cSJim Jagielski res &= oObj.getScriptType("abcd", 0) == ScriptType.LATIN ; 534*b1cdbd2cSJim Jagielski res &= oObj.getScriptType(katakana, 0) == ScriptType.ASIAN; 535*b1cdbd2cSJim Jagielski res &= oObj.getScriptType(arabic, 0) == ScriptType.COMPLEX ; 536*b1cdbd2cSJim Jagielski res &= oObj.getScriptType(arrows, 0) == ScriptType.WEAK ; 537*b1cdbd2cSJim Jagielski 538*b1cdbd2cSJim Jagielski tRes.tested("getScriptType()", res) ; 539*b1cdbd2cSJim Jagielski } 540*b1cdbd2cSJim Jagielski 541*b1cdbd2cSJim Jagielski boolean bCharBlockRes = true; 542*b1cdbd2cSJim Jagielski getCharBlockType(int pos)543*b1cdbd2cSJim Jagielski protected short getCharBlockType(int pos) { 544*b1cdbd2cSJim Jagielski short i = 1; 545*b1cdbd2cSJim Jagielski short cType = 0; 546*b1cdbd2cSJim Jagielski while (i < 31) { 547*b1cdbd2cSJim Jagielski if (oObj.beginOfCharBlock(UnicodeString, pos, locale, i) != -1) { 548*b1cdbd2cSJim Jagielski cType = i; 549*b1cdbd2cSJim Jagielski i = 100; 550*b1cdbd2cSJim Jagielski } 551*b1cdbd2cSJim Jagielski i++; 552*b1cdbd2cSJim Jagielski } 553*b1cdbd2cSJim Jagielski 554*b1cdbd2cSJim Jagielski return cType; 555*b1cdbd2cSJim Jagielski } 556*b1cdbd2cSJim Jagielski 557*b1cdbd2cSJim Jagielski Vector vCharBlockBounds = new Vector(); 558*b1cdbd2cSJim Jagielski Vector vCharBlockTypes = new Vector(); 559*b1cdbd2cSJim Jagielski 560*b1cdbd2cSJim Jagielski /** 561*b1cdbd2cSJim Jagielski * Creates array of all char blocks with their boundaries and 562*b1cdbd2cSJim Jagielski * types using <code>beginOfCharBlock()</code> and 563*b1cdbd2cSJim Jagielski * <code>endOfCharBlock()</code> methods. <p> 564*b1cdbd2cSJim Jagielski * 565*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the end of each boundary is the same 566*b1cdbd2cSJim Jagielski * as start of the next one and if the start of the first block 567*b1cdbd2cSJim Jagielski * has position 0 and the end of the last block is at the end 568*b1cdbd2cSJim Jagielski * of the whole string. 569*b1cdbd2cSJim Jagielski */ _beginOfCharBlock()570*b1cdbd2cSJim Jagielski public void _beginOfCharBlock() { 571*b1cdbd2cSJim Jagielski int iPos = 0; 572*b1cdbd2cSJim Jagielski 573*b1cdbd2cSJim Jagielski while( iPos < UnicodeString.length() && iPos > -1) { 574*b1cdbd2cSJim Jagielski short charType = getCharBlockType(iPos); 575*b1cdbd2cSJim Jagielski int startPos = oObj.beginOfCharBlock(UnicodeString, iPos, 576*b1cdbd2cSJim Jagielski locale, charType); 577*b1cdbd2cSJim Jagielski int endPos = oObj.endOfCharBlock(UnicodeString, iPos, 578*b1cdbd2cSJim Jagielski locale, charType); 579*b1cdbd2cSJim Jagielski iPos = endPos; 580*b1cdbd2cSJim Jagielski vCharBlockBounds.add(new Boundary(startPos, endPos)); 581*b1cdbd2cSJim Jagielski log.println("" + vCharBlockBounds.size() + "). Bounds: [" 582*b1cdbd2cSJim Jagielski + startPos + "," + endPos + "]; Type = " + charType); 583*b1cdbd2cSJim Jagielski vCharBlockTypes.add(new Short(charType)); 584*b1cdbd2cSJim Jagielski } 585*b1cdbd2cSJim Jagielski 586*b1cdbd2cSJim Jagielski for(int i = 0; i < vCharBlockBounds.size() - 1; i++) { 587*b1cdbd2cSJim Jagielski int endPos = ((Boundary)vCharBlockBounds.get(i)).endPos; 588*b1cdbd2cSJim Jagielski int startPos = ((Boundary)vCharBlockBounds.get(i + 1)).startPos; 589*b1cdbd2cSJim Jagielski bCharBlockRes &= endPos == startPos; 590*b1cdbd2cSJim Jagielski } 591*b1cdbd2cSJim Jagielski 592*b1cdbd2cSJim Jagielski log.println("Testing for no intersections : " + bCharBlockRes); 593*b1cdbd2cSJim Jagielski int startPos = ((Boundary)vCharBlockBounds.get(0)).startPos; 594*b1cdbd2cSJim Jagielski bCharBlockRes &= startPos == 0; 595*b1cdbd2cSJim Jagielski int endPos = ((Boundary)vCharBlockBounds.get 596*b1cdbd2cSJim Jagielski (vCharBlockBounds.size() - 1)).endPos; 597*b1cdbd2cSJim Jagielski bCharBlockRes &= endPos == UnicodeString.length(); 598*b1cdbd2cSJim Jagielski log.println("Regions should starts with 0 and ends with " 599*b1cdbd2cSJim Jagielski + UnicodeString.length()); 600*b1cdbd2cSJim Jagielski 601*b1cdbd2cSJim Jagielski tRes.tested("beginOfCharBlock()", bCharBlockRes); 602*b1cdbd2cSJim Jagielski } 603*b1cdbd2cSJim Jagielski 604*b1cdbd2cSJim Jagielski /** 605*b1cdbd2cSJim Jagielski * Testing of this method is performed in <code>beginOfCharBlock()</code> 606*b1cdbd2cSJim Jagielski * method test. <p> 607*b1cdbd2cSJim Jagielski * 608*b1cdbd2cSJim Jagielski * Has the status same as <code>beginOfCharBlock()</code> method status. 609*b1cdbd2cSJim Jagielski */ _endOfCharBlock()610*b1cdbd2cSJim Jagielski public void _endOfCharBlock() { 611*b1cdbd2cSJim Jagielski requiredMethod("beginOfCharBlock()"); 612*b1cdbd2cSJim Jagielski tRes.tested("endOfCharBlock()", bCharBlockRes); 613*b1cdbd2cSJim Jagielski } 614*b1cdbd2cSJim Jagielski 615*b1cdbd2cSJim Jagielski /** 616*b1cdbd2cSJim Jagielski * For every character block obtained in <code>beginOfCharBlock()</code> 617*b1cdbd2cSJim Jagielski * method test (except the first) tries to find its starting position 618*b1cdbd2cSJim Jagielski * by mean of <code>nextCharBlock()</code> method passing as position 619*b1cdbd2cSJim Jagielski * argument the position before the start of a block. <p> 620*b1cdbd2cSJim Jagielski * 621*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the start of every block was found and it's 622*b1cdbd2cSJim Jagielski * equal to this block boundary start. 623*b1cdbd2cSJim Jagielski */ _nextCharBlock()624*b1cdbd2cSJim Jagielski public void _nextCharBlock() { 625*b1cdbd2cSJim Jagielski requiredMethod("beginOfCharBlock()"); 626*b1cdbd2cSJim Jagielski 627*b1cdbd2cSJim Jagielski boolean bRes = true; 628*b1cdbd2cSJim Jagielski for(int i = 0; i < vCharBlockBounds.size(); i++) { 629*b1cdbd2cSJim Jagielski Boundary bounds = (Boundary)vCharBlockBounds.get(i); 630*b1cdbd2cSJim Jagielski Short type = (Short)vCharBlockTypes.get(i); 631*b1cdbd2cSJim Jagielski if (bounds.startPos - 1 < 0) continue; 632*b1cdbd2cSJim Jagielski int iPos = oObj.nextCharBlock(UnicodeString, bounds.startPos - 1, 633*b1cdbd2cSJim Jagielski locale, type.shortValue()); 634*b1cdbd2cSJim Jagielski if (iPos != bounds.startPos) { 635*b1cdbd2cSJim Jagielski bRes = false; 636*b1cdbd2cSJim Jagielski log.println("nextCharBlock(UnicodeString, " 637*b1cdbd2cSJim Jagielski + (bounds.startPos - 1) + ", locale, " + type 638*b1cdbd2cSJim Jagielski + ") should return " + bounds.startPos); 639*b1cdbd2cSJim Jagielski log.println("... and actual value is " + iPos); 640*b1cdbd2cSJim Jagielski } 641*b1cdbd2cSJim Jagielski } 642*b1cdbd2cSJim Jagielski 643*b1cdbd2cSJim Jagielski tRes.tested("nextCharBlock()", bRes); 644*b1cdbd2cSJim Jagielski } 645*b1cdbd2cSJim Jagielski 646*b1cdbd2cSJim Jagielski /** 647*b1cdbd2cSJim Jagielski * For every character block obtained in <code>beginOfCharBlock()</code> 648*b1cdbd2cSJim Jagielski * method test (except the first) tries to find its starting position 649*b1cdbd2cSJim Jagielski * by mean of <code>previousCharBlock()</code> method passing as position 650*b1cdbd2cSJim Jagielski * argument the position after the end of a block. <p> 651*b1cdbd2cSJim Jagielski * 652*b1cdbd2cSJim Jagielski * Has <b>OK</b> status if the start of every block was found and it's 653*b1cdbd2cSJim Jagielski * equal to this block boundary start. 654*b1cdbd2cSJim Jagielski */ _previousCharBlock()655*b1cdbd2cSJim Jagielski public void _previousCharBlock() { 656*b1cdbd2cSJim Jagielski requiredMethod("beginOfCharBlock()"); 657*b1cdbd2cSJim Jagielski 658*b1cdbd2cSJim Jagielski boolean bRes = true; 659*b1cdbd2cSJim Jagielski for(int i = 0; i < vCharBlockBounds.size(); i++) { 660*b1cdbd2cSJim Jagielski Boundary bounds = (Boundary)vCharBlockBounds.get(i); 661*b1cdbd2cSJim Jagielski Short type = (Short)vCharBlockTypes.get(i); 662*b1cdbd2cSJim Jagielski int iPos = oObj.previousCharBlock(UnicodeString, 663*b1cdbd2cSJim Jagielski bounds.endPos + 1, locale, type.shortValue()); 664*b1cdbd2cSJim Jagielski if (iPos != bounds.startPos) { 665*b1cdbd2cSJim Jagielski bRes = false; 666*b1cdbd2cSJim Jagielski log.println("previousCharBlock(UnicodeString, " 667*b1cdbd2cSJim Jagielski + (bounds.endPos + 1) + ", locale, " + type 668*b1cdbd2cSJim Jagielski + ") should return " + bounds.startPos); 669*b1cdbd2cSJim Jagielski log.println("... and actual value is " + iPos); 670*b1cdbd2cSJim Jagielski } 671*b1cdbd2cSJim Jagielski } 672*b1cdbd2cSJim Jagielski 673*b1cdbd2cSJim Jagielski tRes.tested("previousCharBlock()", bRes); 674*b1cdbd2cSJim Jagielski } 675*b1cdbd2cSJim Jagielski 676*b1cdbd2cSJim Jagielski } 677*b1cdbd2cSJim Jagielski 678