Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

11 files changed, 3708 insertions, 0 deletions

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