/*
**********************************************************************
*   Copyright (C) 2001, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
*   Date        Name        Description
*   05/23/00    aliu        Creation.
**********************************************************************
*/
#include "unicode/utypes.h"
#include "unicode/translit.h"
#include "unicode/rbt.h"
#include "unicode/uniset.h"
#include "unicode/unicode.h"
#include "unicode/normlzr.h"
#include "unicode/uchar.h"
#include "transrt.h"
#include "testutil.h"

#define CASE(id,test) case id:                          \
                          name = #test;                 \
                          if (exec) {                   \
                              logln(#test "---");       \
                              logln((UnicodeString)""); \
                              test();                   \
                          }                             \
                          break

#define EXHAUSTIVE(id,test) case id:                            \
                              if(quick==FALSE){                 \
                                  name = #test;                 \
                                  if (exec){                    \
                                      logln(#test "---");       \
                                      logln((UnicodeString)""); \
                                      test();                   \
                                  }                             \
                              }else{                            \
                                name="";                        \
                              }                                 \
                              break
void
TransliteratorRoundTripTest::runIndexedTest(int32_t index, UBool exec,
                                   const char* &name, char* /*par*/) {
    switch (index) {
        CASE(0,TestHiragana);
        CASE(1,TestKatakana);
        //CASE(2,TestArabic);
        //CASE(3,TestHebrew);
        CASE(2,TestGreek);
        CASE(3,Testel);
        CASE(4,TestCyrillic);
        CASE(5,TestDevanagariLatin);

#ifdef ENABLE_FAILING_TESTS
        CASE(6,TestJamo);
        CASE(7,TestJamoHangul);
#else 
        case 6: /* falls through */
        case 7: /* falls through */
#endif
        EXHAUSTIVE(8,TestDevanagariBengali);
        EXHAUSTIVE(9,TestDevanagariGurmukhi);
        EXHAUSTIVE(10,TestDevanagariGujarati);
        EXHAUSTIVE(11,TestDevanagariOriya);
        EXHAUSTIVE(12,TestDevanagariTamil);
        EXHAUSTIVE(13,TestDevanagariTelugu);
        EXHAUSTIVE(14,TestDevanagariKannada);
        EXHAUSTIVE(15,TestDevanagariMalayalam);
        EXHAUSTIVE(16,TestBengaliGurmukhi);
        EXHAUSTIVE(17,TestBengaliGujarati);
        EXHAUSTIVE(18,TestBengaliOriya);
        EXHAUSTIVE(19,TestBengaliTamil);
        EXHAUSTIVE(20,TestBengaliTelugu);
        EXHAUSTIVE(21,TestBengaliKannada);
        EXHAUSTIVE(22,TestBengaliMalayalam );
        EXHAUSTIVE(23,TestGurmukhiGujarati);
        EXHAUSTIVE(24,TestGurmukhiOriya);
        EXHAUSTIVE(25,TestGurmukhiTamil);
        EXHAUSTIVE(26,TestGurmukhiTelugu);
        EXHAUSTIVE(27,TestGurmukhiKannada);
        EXHAUSTIVE(28,TestGurmukhiMalayalam);
        EXHAUSTIVE(29,TestGujaratiOriya);
        EXHAUSTIVE(30,TestGujaratiTamil);
        EXHAUSTIVE(31,TestGujaratiTelugu);
        EXHAUSTIVE(32,TestGujaratiKannada);
        EXHAUSTIVE(33,TestGujaratiMalayalam);
        EXHAUSTIVE(34,TestOriyaTamil);
        EXHAUSTIVE(35,TestOriyaTelugu);
        EXHAUSTIVE(36,TestOriyaKannada);
        EXHAUSTIVE(37,TestOriyaMalayalam);
        EXHAUSTIVE(38,TestTamilTelugu);
        EXHAUSTIVE(39,TestTamilKannada);
        EXHAUSTIVE(40,TestTamilMalayalam);
        EXHAUSTIVE(41,TestTeluguKannada);
        EXHAUSTIVE(42,TestTeluguMalayalam);
        EXHAUSTIVE(43,TestKannadaMalayalam);
        default: name = ""; break;
    }
}

//--------------------------------------------------------------------
// BitSet
//--------------------------------------------------------------------

/**
 * Tiny and incomplete BitSet.  Hardcoded to support 0..FFFF.
 */
class BitSet {
    int32_t bits[65536/32];

public:
    BitSet();
    ~BitSet();
    void clear();
    void set(int32_t x);
    UBool get(int32_t x) const;
};

BitSet::BitSet() {
    clear();
}

BitSet::~BitSet() {
}

void BitSet::clear() {
    int32_t *limit = bits + 65536/32;
    int32_t *p = bits;
    while (p < limit) *p++ = 0;
}

void BitSet::set(int32_t x) {
    x &= 0xFFFF;
    int32_t i = x / 32;
    int32_t bit = 1L << (x & 31);
    bits[i] |= bit;
}

UBool BitSet::get(int32_t x) const {
    x &= 0xFFFF;
    int32_t i = x / 32;
    int32_t bit = 1L << (x & 31);
    return (bits[i] & bit) != 0L;
}

//--------------------------------------------------------------------
// Legal
//--------------------------------------------------------------------

class Legal {
public:
    Legal() {}
    virtual ~Legal() {}
    virtual UBool is(const UnicodeString& sourceString) const {return TRUE;}
};

class LegalGreek : public Legal {
    UBool full;
public:
    LegalGreek(UBool _full) { full = _full; }
    virtual ~LegalGreek() {}

    virtual UBool is(const UnicodeString& sourceString) const;

    static UBool isVowel(UChar c);
    
    static UBool isRho(UChar c);
};

UBool LegalGreek::is(const UnicodeString& sourceString) const { 
    UnicodeString decomp;
    UErrorCode ec = U_ZERO_ERROR;
    Normalizer::decompose(sourceString, FALSE, 0, decomp, ec);
                
    // modern is simpler: don't care about anything but a grave
    if (!full) {
        if (sourceString == CharsToUnicodeString("\\u039C\\u03C0"))
            return FALSE;
        for (int32_t i = 0; i < decomp.length(); ++i) {
            UChar c = decomp.charAt(i);
            // exclude all the accents
            if (c == 0x0313 || c == 0x0314 || c == 0x0300 || c == 0x0302
                || c == 0x0342 || c == 0x0345
                ) return FALSE;
        }
        return TRUE;
    }

    // Legal greek has breathing marks IFF there is a vowel or RHO at the start
    // IF it has them, it has exactly one.
    // IF it starts with a RHO, then the breathing mark must come before the second letter.
    // Since there are no surrogates in greek, don't worry about them
    UBool firstIsVowel = FALSE;
    UBool firstIsRho = FALSE;
    UBool noLetterYet = TRUE;
    int32_t breathingCount = 0;
    int32_t letterCount = 0;
    for (int32_t i = 0; i < decomp.length(); ++i) {
        UChar c = decomp.charAt(i);
        if (u_isalpha(c)) {
            ++letterCount;
            if (noLetterYet) {
                noLetterYet =  FALSE;
                firstIsVowel = isVowel(c);
                firstIsRho = isRho(c);
            }
            if (firstIsRho && letterCount == 2 && breathingCount == 0) return FALSE;
        }
        if (c == 0x0313 || c == 0x0314) {
            ++breathingCount;
        }
    }
    
    if (firstIsVowel || firstIsRho) return breathingCount == 1;
    return breathingCount == 0;
}

UBool LegalGreek::isVowel(UChar c) {
    switch (c) {
    case 0x03B1:
    case 0x03B5:
    case 0x03B7:
    case 0x03B9:
    case 0x03BF:
    case 0x03C5:
    case 0x03C9:
    case 0x0391:
    case 0x0395:
    case 0x0397:
    case 0x0399:
    case 0x039F:
    case 0x03A5:
    case 0x03A9:
        return TRUE;
    }
    return FALSE;
}

UBool LegalGreek::isRho(UChar c) {
    switch (c) {
    case 0x03C1:
    case 0x03A1:
        return TRUE;
    }
    return FALSE;
}

class LegalDeleter {
    Legal* obj;
    Legal*& zeroMe;
public:
    LegalDeleter(Legal* adopted, Legal*& ptrToClean) :
        obj(adopted),
        zeroMe(ptrToClean) {}
    ~LegalDeleter() { delete obj; zeroMe = NULL; }
};

//--------------------------------------------------------------------
// RTTest Interface
//--------------------------------------------------------------------

class RTTest {

    // PrintWriter out;

    UnicodeString transliteratorID; 
    int8_t sourceScript;
    int8_t targetScript;
    int32_t errorLimit;
    int32_t errorCount;
    int32_t pairLimit;
    UnicodeSet sourceRange;
    UnicodeSet targetRange;
    UnicodeSet roundtripExclusions;
    IntlTest* log;
    Legal* legalSource; // NOT owned
    UnicodeSet badCharacters;

public:

    /*
     * create a test for the given script transliterator.
     */
    RTTest(const UnicodeString& transliteratorIDStr, 
           int8_t sourceScriptVal, int8_t targetScriptVal);

    virtual ~RTTest();

    void setErrorLimit(int32_t limit);

    void setPairLimit(int32_t limit);

    void test(const UnicodeString& sourceRange,
              const UnicodeString& targetRange,
              const char* roundtripExclusions,
              IntlTest* log,
              Legal* adoptedLegal);

private:

    // Added to do better equality check.
        
    static UBool isSame(const UnicodeString& a, const UnicodeString& b);
        
    UBool includesSome(const UnicodeSet& set, const UnicodeString& a);
        
    static UBool isCamel(const UnicodeString& a);

    void test2();

    void logWrongScript(const UnicodeString& label,
                        const UnicodeString& from,
                        const UnicodeString& to);
    void logRoundTripFailure(const UnicodeString& from,
                             const UnicodeString& to,
                             const UnicodeString& back);
    void logNotCanonical(const UnicodeString& label,
                         const UnicodeString& from,
                         const UnicodeString& to,
                         const UnicodeString& toCan);

protected:

    /*
     * Characters to filter for source-target mapping completeness
     * Typically is base alphabet, minus extended characters
     * Default is ASCII letters for Latin
     */
    virtual UBool isSource(UChar c);

    /*
     * Characters to check for target back to source mapping.
     * Typically the same as the target script, plus punctuation
     */
    inline UBool isReceivingSource(UChar c);

    /*
     * Characters to filter for target-source mapping
     * Typically is base alphabet, minus extended characters
     */
    inline UBool isTarget(UChar c);

    /*
     * Characters to check for target-source mapping
     * Typically the same as the source script, plus punctuation
     */
    inline UBool isReceivingTarget(UChar c);

    UBool isSource(const UnicodeString& s);
    UBool isTarget(const UnicodeString& s);
    UBool isReceivingSource(const UnicodeString& s);
    UBool isReceivingTarget(const UnicodeString& s);
};

//--------------------------------------------------------------------
// RTTest Implementation
//--------------------------------------------------------------------

/*
 * create a test for the given script transliterator.
 */
RTTest::RTTest(const UnicodeString& transliteratorIDStr, 
               int8_t sourceScriptVal, int8_t targetScriptVal) {
    this->transliteratorID = transliteratorIDStr;
    this->sourceScript = sourceScriptVal;
    this->targetScript = targetScriptVal;
    legalSource = NULL;
    errorLimit = (int32_t)0x7FFFFFFFL;
    errorCount = 0;
    pairLimit  = 0x10000;
}

RTTest::~RTTest() {
}

void RTTest::setErrorLimit(int32_t limit) {
    errorLimit = limit;
}

void RTTest::setPairLimit(int32_t limit) {
    pairLimit = limit;
}

UBool RTTest::isSame(const UnicodeString& a, const UnicodeString& b) {
    if (a == b) return TRUE;
    if (a.caseCompare(b, U_FOLD_CASE_DEFAULT)==0 && isCamel(a)) return TRUE;
    UnicodeString aa, bb;
    UErrorCode ec = U_ZERO_ERROR;
    Normalizer::decompose(a, FALSE, 0, aa, ec);
    Normalizer::decompose(b, FALSE, 0, bb, ec);
    if (aa == bb) return TRUE;
    if (aa.caseCompare(bb, U_FOLD_CASE_DEFAULT)==0 && isCamel(aa)) return TRUE;
    return FALSE;
}

UBool RTTest::includesSome(const UnicodeSet& set, const UnicodeString& a) {
    UChar32 cp;
    for (int32_t i = 0; i < a.length(); i += UTF_CHAR_LENGTH(cp)) {
        cp = a.char32At(i);
        if (set.contains(cp)) return TRUE;
    }
    return FALSE;
}

UBool RTTest::isCamel(const UnicodeString& a) {
    // see if string is of the form aB; e.g. lower, then upper or title
    UChar32 cp;
    UBool haveLower = FALSE;
    for (int32_t i = 0; i < a.length(); i += UTF_CHAR_LENGTH(cp)) {
        cp = a.char32At(i);
        int8_t t = u_charType(cp);
        switch (t) {
        case U_UPPERCASE_LETTER:
            if (haveLower) return TRUE;
            break;
        case U_TITLECASE_LETTER:
            if (haveLower) return TRUE;
            // drop through, since second letter is lower.
        case U_LOWERCASE_LETTER:
            haveLower = TRUE;
            break;
        }
    }
    return FALSE;
}

void RTTest::test(const UnicodeString& sourceRangeVal,
                  const UnicodeString& targetRangeVal,
                  const char* roundtripExclusions,
                  IntlTest* logVal,
                  Legal* adoptedLegal) {

    UErrorCode status = U_ZERO_ERROR;

    this->log = logVal;
    this->legalSource = adoptedLegal;
    LegalDeleter cleaner(adoptedLegal, this->legalSource);

    if (sourceRangeVal.length() > 0) {
        this->sourceRange.applyPattern(sourceRangeVal, status);
        if (U_FAILURE(status)) {
            log->errln("FAIL: UnicodeSet::applyPattern(" +
                       sourceRangeVal + ")");
            return;
        }
    } else {
        this->sourceRange.applyPattern("[a-zA-Z]", status);
        if (U_FAILURE(status)) {
            log->errln("FAIL: UnicodeSet::applyPattern([a-z])");
            return;
        }
    }
    this->targetRange.clear();
    if (targetRangeVal.length() > 0) {
        this->targetRange.applyPattern(targetRangeVal, status);
        if (U_FAILURE(status)) {
            log->errln("FAIL: UnicodeSet::applyPattern(" +
                       targetRangeVal + ")");
            return;
        }
    }
    this->roundtripExclusions.clear();
    if (roundtripExclusions != NULL) {
        UErrorCode ec = U_ZERO_ERROR;
        this->roundtripExclusions.applyPattern(roundtripExclusions, ec);
    }
    if (badCharacters.isEmpty()) {
        UErrorCode ec = U_ZERO_ERROR;
        badCharacters.applyPattern("[:Other:]", ec);
    }

    test2();

    if (errorCount > 0) {
        log->errln(transliteratorID + " errors: " + errorCount); // + ", see " + logFileName);
    } else {
        log->logln(transliteratorID + " ok");
    }
}

void RTTest::logWrongScript(const UnicodeString& label,
                            const UnicodeString& from,
                            const UnicodeString& to) {
    log->errln((UnicodeString)"Fail " +
               label + ": " +
               from + "(" + TestUtility::hex(from) + ") => " +
               to + "(" + TestUtility::hex(to) + ")");
    ++errorCount;
}

void RTTest::logNotCanonical(const UnicodeString& label,
                             const UnicodeString& from,
                             const UnicodeString& to,
                             const UnicodeString& toCan) {
    log->errln((UnicodeString)"Fail (can.equiv)" +
               label + ": " +
               from + "(" + TestUtility::hex(from) + ") => " +
               to + "(" + TestUtility::hex(to) + ")" +
               toCan + " (" +
               TestUtility::hex(to) + ")"
               );
    ++errorCount;
}

void RTTest::logRoundTripFailure(const UnicodeString& from,
                                 const UnicodeString& to,
                                 const UnicodeString& back) {
    if (!legalSource->is(from)) return; // skip illegals

    log->errln((UnicodeString)"Fail Roundtrip: " +
               from + "(" + TestUtility::hex(from) + ") => " +
               to + "(" + TestUtility::hex(to) + ") => " +
               back + "(" + TestUtility::hex(back) + ") => ");
    ++errorCount;
}

/*
 * Characters to filter for source-target mapping completeness
 * Typically is base alphabet, minus extended characters
 * Default is ASCII letters for Latin
 */
UBool RTTest::isSource(UChar c) {
    return (TestUtility::getScript(c) == sourceScript && u_isalpha(c)
        && sourceRange.contains(c));
}

/*
 * Characters to check for target back to source mapping.
 * Typically the same as the target script, plus punctuation
 */
inline UBool
RTTest::isReceivingSource(UChar c) {
    int8_t script = TestUtility::getScript(c);
    return (script == sourceScript || script == TestUtility::COMMON_SCRIPT);
}

/*
 * Characters to filter for target-source mapping
 * Typically is base alphabet, minus extended characters
 */
inline UBool
RTTest::isTarget(UChar c) {
    return (TestUtility::getScript(c) == targetScript && u_isalpha(c)
        && (targetRange.isEmpty() || targetRange.contains(c)));
}

/*
 * Characters to check for target-source mapping
 * Typically the same as the source script, plus punctuation
 */
inline UBool
RTTest::isReceivingTarget(UChar c) {
    int8_t script = TestUtility::getScript(c);
    return (script == targetScript || script == TestUtility::COMMON_SCRIPT);
}

UBool RTTest::isSource(const UnicodeString& s) {
    int32_t length = s.length();
    for (int32_t i = 0; i < length; ++i) {
        if (!isSource(s.charAt(i)))
            return FALSE;
    }
    return TRUE;
}

UBool RTTest::isTarget(const UnicodeString& s) {
    int32_t length = s.length();
    for (int32_t i = 0; i < length; ++i) {
        if (!isTarget(s.charAt(i)))
            return FALSE;
    }
    return TRUE;
}

UBool RTTest::isReceivingSource(const UnicodeString& s) {
    int32_t length = s.length();
    for (int32_t i = 0; i < length; ++i) {
        if (!isReceivingSource(s.charAt(i)))
            return FALSE;
    }
    return TRUE;
}

UBool RTTest::isReceivingTarget(const UnicodeString& s) {
    int32_t length = s.length();
    for (int32_t i = 0; i < length; ++i) {
        if (!isReceivingTarget(s.charAt(i)))
            return FALSE;
    }
    return TRUE;
}

//--------------------------------------------------------------------
// Specific Tests
//--------------------------------------------------------------------

void TransliteratorRoundTripTest::TestHiragana() {
    RTTest test("Latin-Hiragana",
                TestUtility::LATIN_SCRIPT, TestUtility::HIRAGANA_SCRIPT);
    test.test("[a-z]", UnicodeString("[\\u3040-\\u3094]", ""), NULL, this, new Legal());
}

void TransliteratorRoundTripTest::TestKatakana() {
    RTTest test("Latin-Katakana", 
                TestUtility::LATIN_SCRIPT, TestUtility::KATAKANA_SCRIPT);
    test.test("[a-z]", UnicodeString("[\\u30A1-\\u30FA\\u30FC]", ""), NULL, this, new Legal());
}

void TransliteratorRoundTripTest::TestArabic() {
//  RTTest test("Latin-Arabic", 
//              TestUtility::LATIN_SCRIPT, TestUtility::ARABIC_SCRIPT);
//  test.test("[a-z]", UnicodeString("[\\u0620-\\u065F-[\\u0640]]", ""), this, new Legal());
}

void TransliteratorRoundTripTest::TestHebrew() {
//  RTTest test("Latin-Hebrew", 
//              TestUtility::LATIN_SCRIPT, TestUtility::HEBREW_SCRIPT);
//  test.test("", UnicodeString("[\\u05D0-\\u05EF]", ""), this, new Legal());
}

void TransliteratorRoundTripTest::TestJamo() {
    RTTest t("Latin-Jamo", 
             TestUtility::LATIN_SCRIPT, TestUtility::JAMO_SCRIPT);
    t.setErrorLimit(200); // Don't run full test -- too long
    t.test("", "", NULL, this, new Legal());
}

void TransliteratorRoundTripTest::TestJamoHangul() {
    RTTest t("Latin-Hangul", 
             TestUtility::LATIN_SCRIPT, TestUtility::HANGUL_SCRIPT);
    t.setErrorLimit(50); // Don't run full test -- too long
    t.test("", "", NULL, this, new Legal());
}

void TransliteratorRoundTripTest::TestGreek() {
    RTTest test("Latin-Greek", 
                TestUtility::LATIN_SCRIPT, TestUtility::GREEK_SCRIPT);
    test.test("", UnicodeString("[\\u003B\\u00B7[:Greek:]-[\\u03D7-\\u03EF]]", ""),
              "[\\u037A\\u03D0-\\u03F5]", /* exclusions */
              this, new LegalGreek(TRUE));
}

void TransliteratorRoundTripTest::Testel() {
    RTTest test("Latin-el", 
                TestUtility::LATIN_SCRIPT, TestUtility::GREEK_SCRIPT);
    test.test("", "[\\u003B\\u00B7[:Greek:]-[\\u03D7-\\u03EF]]", 
              "[\\u037A\\u03D0-\\u03F5]", /* exclusions */
              this, new LegalGreek(FALSE));
    }

void TransliteratorRoundTripTest::TestCyrillic() {
    RTTest test("Latin-Cyrillic", 
                TestUtility::LATIN_SCRIPT, TestUtility::CYRILLIC_SCRIPT);
    test.test("", UnicodeString("[\\u0400-\\u045F]", ""), NULL, this, new Legal());
}


//----------------------------------
// Inter-Indic Tests
//----------------------------------
void TransliteratorRoundTripTest::TestDevanagariLatin() {
    RTTest test("Latin-DEVANAGARI", 
                TestUtility::LATIN_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
    test.test("", "[:Devanagari:]", NULL, this, new Legal());
}

void TransliteratorRoundTripTest::TestDevanagariBengali()  {
    RTTest test("BENGALI-DEVANAGARI", 
        TestUtility::BENGALI_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
         test.test("[:BENGALI:]", "[:Devanagari:]", 
                "[\\u0950\\u0935\\u0912\\u0933\\u090e\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]\\u09F0\\u09F1]", /*roundtrip exclusions*/
                this, new Legal());
    RTTest test1("DEVANAGARI-BENGALI", 
            TestUtility::DEVANAGARI_SCRIPT, TestUtility::BENGALI_SCRIPT );
          test1.test( "[:Devanagari:]", "[:BENGALI:]",
                  "[\\u0950\\u0935\\u0912\\u0933\\u090e\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]\\u09F0\\u09F1]", /*roundtrip exclusions*/
                  this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariGurmukhi()  {
    RTTest test("GURMUKHI-DEVANAGARI", 
      TestUtility::GURMUKHI_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:GURMUKHI:]", "[:Devanagari:]", 
            "[\\u0950\\u090D\\u090e\\u0912\\u0911\\u090b\\u090c\\u0934\\u0960\\u0961\\u0937\\u0a72\\u0a73\\u0a74\\u093d]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-GURMUKHI", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::GURMUKHI_SCRIPT );
      test1.test( "[:Devanagari:]", "[:GURMUKHI:]",
              "[\\u0950\\u090D\\u090e\\u0912\\u0911\\u090b\\u090c\\u0934\\u0960\\u0961\\u0937\\u0a72\\u0a73\\u0a74\\u093d]", /*roundtrip exclusions*/
              this, new Legal());
} 
void TransliteratorRoundTripTest::TestDevanagariGujarati()  {
    RTTest test("GUJARATI-DEVANAGARI", 
      TestUtility::GUJARATI_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:GUJARATI:]", "[:Devanagari:]", 
            "[\\u0961\\u090c\\u090e\\u0912]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-GUJARATI", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::GUJARATI_SCRIPT );
      test1.test( "[:Devanagari:]", "[:GUJARATI:]",NULL,
              this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariOriya()  {
    RTTest test("ORIYA-DEVANAGARI", 
      TestUtility::ORIYA_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:ORIYA:]", "[:Devanagari:]", 
            "[\\u0950\\u090D\\u090e\\u0912\\u0911\\u0931\\u0935]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-ORIYA", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::ORIYA_SCRIPT );
      test1.test( "[:Devanagari:]", "[:ORIYA:]",
              "[\\u0950\\u090D\\u090e\\u0912\\u0911\\u0931\\u0935]", /*roundtrip exclusions*/ 
              this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariTamil()  {
    RTTest test("Tamil-DEVANAGARI", 
      TestUtility::TAMIL_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:tamil:]", "[:Devanagari:]", 
              "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]"
              "\\u090B\\u090C\\u0916\\u0917\\u0918\\u091B\\u091D\\u0920\\u0921"
              "\\u0922\\u0925\\u0926\\u0927\\u092B\\u092C\\u092D\\u0936\\u0960\\u0961]", /*roundtrip exclusions*/
              this, new Legal());
    RTTest test1("DEVANAGARI-Tamil", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::TAMIL_SCRIPT );
      test1.test( "[:Devanagari:]", "[:tamil:]",
              "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariTelugu()  {
    RTTest test("Telugu-DEVANAGARI", 
      TestUtility::TELUGU_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:telugu:]", "[:Devanagari:]", 
            "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-TELUGU", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::TELUGU_SCRIPT );
      test1.test( "[:Devanagari:]", "[:TELUGU:]",
              "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariKannada()  {
    RTTest test("KANNADA-DEVANAGARI", 
      TestUtility::KANNADA_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:KANNADA:]", "[:Devanagari:]", 
            "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-KANNADA", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::KANNADA_SCRIPT );
      test1.test( "[:Devanagari:]", "[:KANNADA:]",
              "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestDevanagariMalayalam()  {
    RTTest test("MALAYALAM-DEVANAGARI", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::DEVANAGARI_SCRIPT);
      test.test("[:MALAYALAM:]", "[:Devanagari:]", 
            "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("DEVANAGARI-MALAYALAM", 
        TestUtility::DEVANAGARI_SCRIPT, TestUtility::MALAYALAM_SCRIPT );
      test1.test( "[:Devanagari:]", "[:MALAYALAM:]",
              "[\\u0950\\u090D\\u0911\\u093d\\u0929\\u0934[\\u0958-\\u095f]]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliGurmukhi()  {
    RTTest test("GURMUKHI-BENGALI", 
      TestUtility::GURMUKHI_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:GURMUKHI:]", "[:BENGALI:]",  
            "[\\u098B\\u098C\\u09B7\\u09E0\\u09E1\\u09F0\\u09F1]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-GURMUKHI", 
        TestUtility::BENGALI_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test1.test( "[:BENGALI:]", "[:GURMUKHI:]",
              "[\\u0A33\\u0A35\\u0A59\\u0A5A\\u0A5B\\u0A5E\\u0A72\\u0A73\\u0A74]", /*roundtrip exclusions*/
              this, new Legal());
} 
void TransliteratorRoundTripTest::TestBengaliGujarati()  {
    RTTest test("GUJARATI-BENGALI", 
      TestUtility::GUJARATI_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:GUJARATI:]", "[:BENGALI:]", 
            "[\\u098c\\u09e1\\u09f0\\u09f1]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-GUJARATI", 
        TestUtility::BENGALI_SCRIPT, TestUtility::GUJARATI_SCRIPT);
      test1.test( "[:BENGALI:]", "[:GUJARATI:]",
              "[\\u0A8D\\u0A91\\u0AB3\\u0AB5\\u0ABD\\u0AD0]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliOriya()  {
    RTTest test("ORIYA-BENGALI", 
      TestUtility::ORIYA_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:ORIYA:]", "[:BENGALI:]", 
            "[\\u09f0\\u09f1]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-ORIYA", 
        TestUtility::BENGALI_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test1.test( "[:BENGALI:]", "[:ORIYA:]",
              "[\\u0b33\\u0b3d]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliTamil()  {
    RTTest test("Tamil-BENGALI", 
      TestUtility::TAMIL_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:tamil:]", "[:BENGALI:]", 
              "[\\u09f0\\u09f1\\u098B\\u098C\\u0996\\u0997\\u0998\\u099B\\u099D\\u09A0\\u09A1\\u09A2\\u09A5\\u09A6\\u09A7\\u09AB\\u09AC\\u09AD\\u09B6\\u09DC\\u09DD\\u09DF\\u09E0\\u09E1]", /*roundtrip exclusions*/
              this, new Legal());
    RTTest test1("BENGALI-Tamil", 
        TestUtility::BENGALI_SCRIPT, TestUtility::TAMIL_SCRIPT);
      test1.test( "[:BENGALI:]", "[:tamil:]",
              "[\\u0B8E\\u0B92\\u0BA9\\u0BB1\\u0BB3\\u0BB4\\u0BB5]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliTelugu()  {
    RTTest test("Telugu-BENGALI", 
      TestUtility::TELUGU_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:telugu:]", "[:BENGALI:]", 
            "[\\u09f0\\u09f1\\u09dc\\u09dd\\u09df]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-TELUGU", 
        TestUtility::BENGALI_SCRIPT, TestUtility::TELUGU_SCRIPT);
      test1.test( "[:BENGALI:]", "[:TELUGU:]",
              "[\\u0C0E\\u0C12\\u0C31\\u0C33\\u0C35]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliKannada()  {
    RTTest test("KANNADA-BENGALI", 
      TestUtility::KANNADA_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:KANNADA:]", "[:BENGALI:]", 
            "[\\u09f0\\u09f1\\u09dc\\u09dd\\u09df]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-KANNADA", 
        TestUtility::BENGALI_SCRIPT, TestUtility::KANNADA_SCRIPT);
      test1.test( "[:BENGALI:]", "[:KANNADA:]",
              "[\\u0C8E\\u0C92\\u0CB1\\u0cb3\\u0cb5\\u0cde]", /*roundtrip exclusions*/ 
              this, new Legal());
}
void TransliteratorRoundTripTest::TestBengaliMalayalam()  {
    RTTest test("MALAYALAM-BENGALI", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::BENGALI_SCRIPT);
      test.test("[:MALAYALAM:]", "[:BENGALI:]", 
            "[\\u09f0\\u09f1\\u09dc\\u09dd\\u09df]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("BENGALI-MALAYALAM", 
        TestUtility::BENGALI_SCRIPT, TestUtility::MALAYALAM_SCRIPT);
      test1.test( "[:BENGALI:]", "[:MALAYALAM:]",
              "[\\u0d31-\\u0d35\\u0d0e\\u0d12]", /*roundtrip exclusions*/
              this, new Legal());
} 
void TransliteratorRoundTripTest::TestGurmukhiGujarati()  {
    RTTest test("GUJARATI-GURMUKHI", 
      TestUtility::GUJARATI_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:GUJARATI:]", "[:GURMUKHI:]", 
            "[\\u0a5c\\u0a72\\u0a73\\u0a74\\u0a8b\\u0a8d\\u0a91\\u0abd]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-GUJARATI", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::GUJARATI_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:GUJARATI:]",
              "[\\u0a5c\\u0a72\\u0a73\\u0a74\\u0a8b\\u0a8d\\u0a91\\u0ab7\\u0abd\\u0ad0\\u0ae0]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGurmukhiOriya()  {
    RTTest test("ORIYA-GURMUKHI", 
      TestUtility::ORIYA_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:ORIYA:]", "[:GURMUKHI:]", 
            "[\\u0B0B\\u0B0C\\u0B37\\u0B3D\\u0B5F\\u0B60\\u0B61\\u0a35\\u0a72\\u0a73\\u0a74]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-ORIYA", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::ORIYA_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:ORIYA:]",
              "[\\u0B0B\\u0B0C\\u0B37\\u0B3D\\u0B5F\\u0B60\\u0B61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGurmukhiTamil()  {
    RTTest test("TAMIL-GURMUKHI", 
      TestUtility::TAMIL_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:TAMIL:]", "[:GURMUKHI:]", 
            "[\\u0A16\\u0A17\\u0A18\\u0A1B\\u0A1D\\u0A20\\u0A21\\u0A22\\u0A25\\u0A26\\u0A27\\u0A2B\\u0A2C\\u0A2D\\u0A59\\u0A5A\\u0A5B\\u0A5C\\u0A5E\\u0A72\\u0A73\\u0A74]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-TAMIL", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::TAMIL_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:TAMIL:]",
              "[\\u0B8E\\u0B92\\u0BA9\\u0BB1\\u0BB4]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGurmukhiTelugu()  {
    RTTest test("TELUGU-GURMUKHI", 
      TestUtility::TELUGU_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:TELUGU:]", "[:GURMUKHI:]", 
            "[\\u0A59\\u0A5A\\u0A5B\\u0A5C\\u0A5E\\u0A72\\u0A73\\u0A74]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-TELUGU", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::TELUGU_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:TELUGU:]",
              "[\\u0C0B\\u0C0C\\u0C0E\\u0C12\\u0C31\\u0C37\\u0C60\\u0C61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGurmukhiKannada()  {
    RTTest test("KANNADA-GURMUKHI", 
      TestUtility::KANNADA_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:KANNADA:]", "[:GURMUKHI:]", 
            "[\\u0A59\\u0A5A\\u0A5B\\u0A5C\\u0A5E\\u0A72\\u0A73\\u0A74]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-KANNADA", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::KANNADA_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:KANNADA:]",
              "[\\u0C8B\\u0C8C\\u0C8E\\u0C92\\u0CB1\\u0CB7\\u0CE0\\u0CE1]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGurmukhiMalayalam()  {
    RTTest test("MALAYALAM-GURMUKHI", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::GURMUKHI_SCRIPT);
      test.test("[:MALAYALAM:]", "[:GURMUKHI:]", 
            "[\\u0A59\\u0A5A\\u0A5B\\u0A5C\\u0A5E\\u0A72\\u0A73\\u0A74]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GURMUKHI-MALAYALAM", 
        TestUtility::GURMUKHI_SCRIPT, TestUtility::MALAYALAM_SCRIPT);;
      test1.test( "[:GURMUKHI:]", "[:MALAYALAM:]",
              "[\\u0D0B\\u0D0C\\u0D0E\\u0D12\\u0D31\\u0D34\\u0D37\\u0D60\\u0D61]", /*roundtrip exclusions*/
              this, new Legal());
}

 void TransliteratorRoundTripTest::TestGujaratiOriya()  {
    RTTest test("GUJARATI-ORIYA", 
      TestUtility::GUJARATI_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test.test("[:GUJARATI:]", "[:ORIYA:]", 
            "[\\u0B0C\\u0B5F\\u0B61]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("ORIYA-GUJARATI", 
        TestUtility::ORIYA_SCRIPT, TestUtility::GUJARATI_SCRIPT);;
      test1.test( "[:ORIYA:]", "[:GUJARATI:]",
              "[\\u0A8D\\u0A91\\u0AB5\\u0Ad0]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGujaratiTamil()  {
    RTTest test("TAMIL-GUJARATI", 
      TestUtility::TAMIL_SCRIPT, TestUtility::GUJARATI_SCRIPT);
      test.test("[:TAMIL:]", "[:GUJARATI:]", 
            "[\\u0A8B\\u0A8D\\u0A91\\u0A96\\u0A97\\u0A98\\u0A9B\\u0A9D\\u0AA0\\u0AA1\\u0AA2\\u0AA5\\u0AA6\\u0AA7\\u0AAB\\u0AAC\\u0AAD\\u0AB6\\u0ABD\\u0AD0\\u0AE0]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GUJARATI-TAMIL", 
        TestUtility::GUJARATI_SCRIPT, TestUtility::TAMIL_SCRIPT);;
      test1.test( "[:GUJARATI:]", "[:TAMIL:]",
              "[\\u0B8E\\u0B92\\u0BA9\\u0BB1\\u0BB4]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGujaratiTelugu()  {
    RTTest test("TELUGU-GUJARATI", 
      TestUtility::TELUGU_SCRIPT, TestUtility::GUJARATI_SCRIPT);
      test.test("[:TELUGU:]", "[:GUJARATI:]", 
            "[\\u0A8D\\u0A91\\u0ABD\\u0Ad0]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GUJARATI-TELUGU", 
        TestUtility::GUJARATI_SCRIPT, TestUtility::TELUGU_SCRIPT);;
      test1.test( "[:GUJARATI:]", "[:TELUGU:]",
              "[\\u0C0C\\u0C0E\\u0C12\\u0C31\\u0C61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGujaratiKannada()  {
    RTTest test("KANNADA-GUJARATI", 
      TestUtility::KANNADA_SCRIPT, TestUtility::GUJARATI_SCRIPT);
      test.test("[:KANNADA:]", "[:GUJARATI:]", 
            "[\\u0A8D\\u0A91\\u0ABD\\u0Ad0]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GUJARATI-KANNADA", 
        TestUtility::GUJARATI_SCRIPT, TestUtility::KANNADA_SCRIPT);;
      test1.test( "[:GUJARATI:]", "[:KANNADA:]",
              "[\\u0C8C\\u0C8E\\u0C92\\u0CB1\\u0CDE\\u0CE1]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestGujaratiMalayalam()  {
    RTTest test("MALAYALAM-GUJARATI", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::GUJARATI_SCRIPT);
      test.test("[:MALAYALAM:]", "[:GUJARATI:]", 
            "[\\u0A8D\\u0A91\\u0ABD\\u0Ad0]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("GUJARATI-MALAYALAM", 
        TestUtility::GUJARATI_SCRIPT, TestUtility::MALAYALAM_SCRIPT);;
      test1.test( "[:GUJARATI:]", "[:MALAYALAM:]",
              "[\\u0D0C\\u0D0E\\u0D12\\u0D31\\u0D34\\u0D61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestOriyaTamil()  {
    RTTest test("TAMIL-ORIYA", 
      TestUtility::TAMIL_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test.test("[:TAMIL:]", "[:ORIYA:]", 
            "[\\u0B0B\\u0B0C\\u0B16\\u0B17\\u0B18\\u0B1B\\u0B1D\\u0B20\\u0B21\\u0B22\\u0B25\\u0B26\\u0B27\\u0B2B\\u0B2C\\u0B2D\\u0B36\\u0B3D\\u0B5C\\u0B5D\\u0B5F\\u0B60\\u0B61]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("ORIYA-TAMIL", 
        TestUtility::ORIYA_SCRIPT, TestUtility::TAMIL_SCRIPT);;
      test1.test( "[:ORIYA:]", "[:TAMIL:]",
              "[\\u0B8E\\u0B92\\u0BA9\\u0BB1\\u0BB4\\u0BB5]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestOriyaTelugu()  {
    RTTest test("TELUGU-ORIYA", 
      TestUtility::TELUGU_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test.test("[:TELUGU:]", "[:ORIYA:]", 
            "[\\u0B3D\\u0B5C\\u0B5D\\u0B5F]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("ORIYA-TELUGU", 
        TestUtility::ORIYA_SCRIPT, TestUtility::TELUGU_SCRIPT);;
      test1.test( "[:ORIYA:]", "[:TELUGU:]",
              "[\\u0C0E\\u0C12\\u0C31\\u0C35]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestOriyaKannada()  {
    RTTest test("KANNADA-ORIYA", 
      TestUtility::KANNADA_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test.test("[:KANNADA:]", "[:ORIYA:]", 
            "[\\u0B3D\\u0B5C\\u0B5D\\u0B5F]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("ORIYA-KANNADA", 
        TestUtility::ORIYA_SCRIPT, TestUtility::KANNADA_SCRIPT);;
      test1.test( "[:ORIYA:]", "[:KANNADA:]",
              "[\\u0C8E\\u0C92\\u0CB1\\u0CB5\\u0CDE]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestOriyaMalayalam()  {
    RTTest test("MALAYALAM-ORIYA", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::ORIYA_SCRIPT);
      test.test("[:MALAYALAM:]", "[:ORIYA:]", 
            "[\\u0B3D\\u0B5C\\u0B5D\\u0B5F]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("ORIYA-MALAYALAM", 
        TestUtility::ORIYA_SCRIPT, TestUtility::MALAYALAM_SCRIPT);;
      test1.test( "[:ORIYA:]", "[:MALAYALAM:]",
              "[\\u0D0E\\u0D12\\u0D31\\u0D34\\u0D35]", /*roundtrip exclusions*/
              this, new Legal());
}

void TransliteratorRoundTripTest::TestTamilTelugu()  {
    RTTest test("TELUGU-TAMIL", 
      TestUtility::TELUGU_SCRIPT, TestUtility::TAMIL_SCRIPT);
      test.test("[:TELUGU:]", "[:TAMIL:]", 
            "[\\u0ba9\\u0bb4]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("TAMIL-TELUGU", 
        TestUtility::TAMIL_SCRIPT, TestUtility::TELUGU_SCRIPT);;
      test1.test( "[:TAMIL:]", "[:TELUGU:]",
              "[\\u0C0B\\u0C0C\\u0C16\\u0C17\\u0C18\\u0C1B\\u0C1D\\u0C20\\u0C21\\u0C22\\u0C25\\u0C26\\u0C27\\u0C2B\\u0C2C\\u0C2D\\u0C36\\u0C60\\u0C61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestTamilKannada()  {
    RTTest test("KANNADA-TAMIL", 
      TestUtility::KANNADA_SCRIPT, TestUtility::TAMIL_SCRIPT);
      test.test("[:KANNADA:]", "[:TAMIL:]", 
            "[\\u0ba9\\u0bb4]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("TAMIL-KANNADA", 
        TestUtility::TAMIL_SCRIPT, TestUtility::KANNADA_SCRIPT);;
      test1.test( "[:TAMIL:]", "[:KANNADA:]",
              "[\\u0C8B\\u0C8C\\u0C96\\u0C97\\u0C98\\u0C9B\\u0C9D\\u0CA0\\u0CA1\\u0CA2\\u0CA5\\u0CA6\\u0CA7\\u0CAB\\u0CAC\\u0CAD\\u0CB6\\u0CDE\\u0CE0\\u0CE1]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestTamilMalayalam()  {
    RTTest test("MALAYALAM-TAMIL", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::TAMIL_SCRIPT);
      test.test("[:MALAYALAM:]", "[:TAMIL:]", 
            "[\\u0ba9]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("TAMIL-MALAYALAM", 
        TestUtility::TAMIL_SCRIPT, TestUtility::MALAYALAM_SCRIPT);;
      test1.test( "[:TAMIL:]", "[:MALAYALAM:]",
              "[\\u0D0B\\u0D0C\\u0D16\\u0D17\\u0D18\\u0D1B\\u0D1D\\u0D20\\u0D21\\u0D22\\u0D25\\u0D26\\u0D27\\u0D2B\\u0D2C\\u0D2D\\u0D36\\u0D60\\u0D61]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestTeluguKannada()  {
    RTTest test("KANNADA-TELUGU", 
      TestUtility::KANNADA_SCRIPT, TestUtility::TELUGU_SCRIPT);
      test.test("[:KANNADA:]", "[:TELUGU:]", 
            "[]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("TELUGU-KANNADA", 
        TestUtility::TELUGU_SCRIPT, TestUtility::KANNADA_SCRIPT);;
      test1.test( "[:TELUGU:]", "[:KANNADA:]",
              "[\\u0CDE]", /*roundtrip exclusions*/
              this, new Legal());
}
void TransliteratorRoundTripTest::TestTeluguMalayalam()  {
    RTTest test("MALAYALAM-TELUGU", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::TELUGU_SCRIPT);
      test.test("[:MALAYALAM:]", "[:TELUGU:]", 
            "[]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("TELUGU-MALAYALAM", 
        TestUtility::TELUGU_SCRIPT, TestUtility::MALAYALAM_SCRIPT);;
      test1.test( "[:TELUGU:]", "[:MALAYALAM:]",
              "[\\u0D34]", /*roundtrip exclusions*/
              this, new Legal());
}

void TransliteratorRoundTripTest::TestKannadaMalayalam()  {
    RTTest test("MALAYALAM-KANNADA", 
      TestUtility::MALAYALAM_SCRIPT, TestUtility::KANNADA_SCRIPT);
      test.test("[:MALAYALAM:]", "[:KANNADA:]", 
            "[\\u0cDe]", /*roundtrip exclusions*/
            this, new Legal());
    RTTest test1("KANNADA-MALAYALAM", 
        TestUtility::KANNADA_SCRIPT, TestUtility::MALAYALAM_SCRIPT);
      test1.test( "[:KANNADA:]", "[:MALAYALAM:]",
              "[\\u0D34]", /*roundtrip exclusions*/
              this, new Legal());
}

//---------------
// End Indic
//---------------

void RTTest::test2() {

    UChar c;
    UnicodeString cs, targ, reverse;
    int8_t *type = new int8_t[0xFFFF];
    UParseError parseError;
    UErrorCode status = U_ZERO_ERROR;
    Transliterator* sourceToTarget = Transliterator::createInstance(transliteratorID, UTRANS_FORWARD, parseError, status);
    if (sourceToTarget == NULL) {
        log->errln("Fail: createInstance(" + transliteratorID +
                   ") returned NULL");
        return;
    }
    Transliterator* targetToSource = sourceToTarget->createInverse(status);
    if (targetToSource == NULL) {
        log->errln("Fail: " + transliteratorID +
                   ".createInverse() returned NULL");
        delete sourceToTarget;
        return;
    }

    log->logln("Initializing type array");

    for (c = 0; c < 0xFFFF; ++c) {
        type[c] = u_charType(c);
    }

    BitSet failSourceTarg;

    log->logln("Checking that all source characters convert to target - Singles");

    for (c = 0; c < 0xFFFF; ++c) {
        if (type[c] == U_UNASSIGNED || !isSource(c))
            continue;
        cs.remove();
        cs.append(c);
        targ = cs;
        sourceToTarget->transliterate(targ);
        if (!isReceivingTarget(targ) || includesSome(badCharacters, targ)) {
            logWrongScript("Source-Target", cs, targ);
            failSourceTarg.set(c);
            if (errorCount >= errorLimit)
                return;
        } else {
            UnicodeString cs2;
            UErrorCode ec = U_ZERO_ERROR;
            Normalizer::decompose(cs, FALSE, 0, cs2, ec);
            UnicodeString targ2 = cs2;
            sourceToTarget->transliterate(targ2);
            if (targ != targ2) {
                logNotCanonical("Source-Target", cs, targ, targ2);
                if (errorCount >= errorLimit)
                    return;
            }
        }
    }

    log->logln("Checking that all source characters convert to target - Doubles");

    for (c = 0; c < 0xFFFF; ++c) {
        if (type[c] == U_UNASSIGNED ||
            !isSource(c)) continue;
        if (failSourceTarg.get(c)) continue;

        for (UChar d = 0; d < 0xFFFF; ++d) {
            if (type[d] == U_UNASSIGNED || !isSource(d))
                continue;
            if (failSourceTarg.get(d)) continue;

            cs.remove();
            cs.append(c).append(d);
            targ = cs;
            sourceToTarget->transliterate(targ);
            if (!isReceivingTarget(targ) || includesSome(badCharacters, targ)) {
                logWrongScript("Source-Target", cs, targ);
                if (errorCount >= errorLimit)
                    return;
            } else {
                UnicodeString cs2;
                UErrorCode ec = U_ZERO_ERROR;
                Normalizer::decompose(cs, FALSE, 0, cs2, ec);
                UnicodeString targ2 = cs2;
                sourceToTarget->transliterate(targ2);
                if (targ != targ2) {
                    logNotCanonical("Source-Target", cs, targ, targ2);
                    if (errorCount >= errorLimit)
                        return;
                }
            }
        }
    }

    log->logln("Checking that target characters convert to source and back - Singles");

    BitSet failTargSource;
    BitSet failRound;

    for (c = 0; c < 0xFFFF; ++c) {
        if (type[c] == U_UNASSIGNED || !isTarget(c))
            continue;
        cs.remove();
        cs.append(c);
        targ = cs;
        targetToSource->transliterate(targ);
        reverse = targ;
        sourceToTarget->transliterate(reverse);
        if (!isReceivingSource(targ) || includesSome(badCharacters, targ)) {
            logWrongScript("Target-Source", cs, targ);
            failTargSource.set(c);
            if (errorCount >= errorLimit)
                return;
        } else if (!isSame(cs, reverse) && !roundtripExclusions.contains(c)) {
            logRoundTripFailure(cs, targ, reverse);
            failRound.set(c);
            if (errorCount >= errorLimit)
                return;
        } else {
            UnicodeString targ2;
            UErrorCode ec = U_ZERO_ERROR;
            Normalizer::decompose(targ, FALSE, 0, targ2, ec);
            UnicodeString reverse2 = targ2;
            sourceToTarget->transliterate(reverse2);
            if (reverse != reverse2) {
                logNotCanonical("Target-Source", cs, targ, targ2);
                if (errorCount >= errorLimit)
                    return;
            }
        }
    }

    log->logln("Checking that target characters convert to source and back - Doubles");
    int32_t count = 0;
    cs = UNICODE_STRING("aa", 2);
    for (c = 0; c < 0xFFFF; ++c) {
        if (type[c] == U_UNASSIGNED || !isTarget(c))
            continue;
        if (++count > pairLimit) {
            //throw new TestTruncated("Test truncated at " + pairLimit + " x 64k pairs");
            log->logln("");
            log->logln((UnicodeString)"Test truncated at " + pairLimit + " x 64k pairs");
            return;
        }
        cs.setCharAt(0, c);
        log->log(TestUtility::hex(c));
        for (UChar d = 0; d < 0xFFFF; ++d) {
            if (type[d] == U_UNASSIGNED || !isTarget(d))
                continue;
            cs.setCharAt(1, d);
            targ = cs;
            targetToSource->transliterate(targ);
            reverse = targ;
            sourceToTarget->transliterate(reverse);
            if (!isReceivingSource(targ) && !failTargSource.get(c) && !failTargSource.get(d)
                || includesSome(badCharacters, targ)) {
                logWrongScript("Target-Source", cs, targ);
                if (errorCount >= errorLimit)
                    return;
            } else if (!isSame(cs, reverse) && !failRound.get(c) && !failRound.get(d)
                       && !roundtripExclusions.contains(c) && !roundtripExclusions.contains(d)) {
                logRoundTripFailure(cs, targ, reverse);
                if (errorCount >= errorLimit)
                    return;
            } else {
                UnicodeString targ2;
                UErrorCode ec = U_ZERO_ERROR;
                Normalizer::decompose(targ, FALSE, 0, targ2, ec);
                UnicodeString reverse2 = targ2;
                sourceToTarget->transliterate(reverse2);
                if (reverse != reverse2) {
                    logNotCanonical("Target-Source", cs, targ, targ2);
                    if (errorCount >= errorLimit)
                        return;
                }
            }
        }
    }
    log->logln("");
    delete []type;
    delete sourceToTarget;
    delete targetToSource;
}