src/third_party/icu/source/test/intltest/reptest.cpp - cobalt - Git at Google

 /********************************************************************
  * COPYRIGHT:
  * Copyright (c) 2001-2010, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /************************************************************************
 *   This test program is intended for testing Replaceable class.
 *
 *   Date        Name        Description
 *   11/28/2001  hshih       Ported back from Java.
 *
 ************************************************************************/

 #include "unicode/utypes.h"

 #if !UCONFIG_NO_TRANSLITERATION

 #include "ittrans.h"
 #include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include "unicode/rep.h"
 #include "reptest.h"

 //---------------------------------------------
 // runIndexedTest
 //---------------------------------------------

     /**
      * This is a test class that simulates styled text.
      * It associates a style number (0..65535) with each character,
      * and maintains that style in the normal fashion:
      * When setting text from raw string or characters,<br>
      * Set the styles to the style of the first character replaced.<br>
      * If no characters are replaced, use the style of the previous character.<br>
      * If at start, use the following character<br>
      * Otherwise use NO_STYLE.
      */
 class TestReplaceable : public Replaceable {
     UnicodeString chars;
     UnicodeString styles;

     static const UChar NO_STYLE;

     static const UChar NO_STYLE_MARK;

     /**
      * The address of this static class variable serves as this class's ID
      * for ICU "poor man's RTTI".
      */
     static const char fgClassID;

 public:
     TestReplaceable (const UnicodeString& text,
                      const UnicodeString& newStyles) {
         chars = text;
         UnicodeString s;
         for (int i = 0; i < text.length(); ++i) {
             if (i < newStyles.length()) {
                 s.append(newStyles.charAt(i));
             } else {
                 if (text.charAt(i) == NO_STYLE_MARK) {
                     s.append(NO_STYLE);
                 } else {
                     s.append((UChar)(i + 0x0031));
                 }
             }
         }
         this->styles = s;
     }

     virtual Replaceable *clone() const {
         return new TestReplaceable(chars, styles);
     }

     ~TestReplaceable(void) {}

     UnicodeString getStyles() {
         return styles;
     }

     UnicodeString toString() {
         UnicodeString s = chars;
         s.append("{");
         s.append(styles);
         s.append("}");
         return s;
     }

     void extractBetween(int32_t start, int32_t limit, UnicodeString& result) const {
         chars.extractBetween(start, limit, result);
     }

     /**
      * ICU "poor man's RTTI", returns a UClassID for this class.
      *
      * @draft ICU 2.2
      */
     static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }

     /**
      * ICU "poor man's RTTI", returns a UClassID for the actual class.
      *
      * @draft ICU 2.2
      */
     virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }

 protected:
     virtual int32_t getLength() const {
         return chars.length();
     }

     virtual UChar getCharAt(int32_t offset) const{
         return chars.charAt(offset);
     }

     virtual UChar32 getChar32At(int32_t offset) const{
         return chars.char32At(offset);
     }

     void fixStyles(int32_t start, int32_t limit, int32_t newLen) {
         UChar newStyle = NO_STYLE;
         if (start != limit && styles.charAt(start) != NO_STYLE) {
             newStyle = styles.charAt(start);
         } else if (start > 0 && getCharAt(start-1) != NO_STYLE_MARK) {
             newStyle = styles.charAt(start-1);
         } else if (limit < styles.length()) {
             newStyle = styles.charAt(limit);
         }
         // dumb implementation for now.
         UnicodeString s;
         for (int i = 0; i < newLen; ++i) {
             // this doesn't really handle an embedded NO_STYLE_MARK
             // in the middle of a long run of characters right -- but
             // that case shouldn't happen anyway
             if (getCharAt(start+i) == NO_STYLE_MARK) {
                 s.append(NO_STYLE);
             } else {
                 s.append(newStyle);
             }
         }
         styles.replaceBetween(start, limit, s);
     }

     virtual void handleReplaceBetween(int32_t start, int32_t limit, const UnicodeString& text) {
         UnicodeString s;
         this->extractBetween(start, limit, s);
         if (s == text) return; // NO ACTION!
         this->chars.replaceBetween(start, limit, text);
         fixStyles(start, limit, text.length());
     }


     virtual void copy(int32_t start, int32_t limit, int32_t dest) {
         chars.copy(start, limit, dest);
         styles.copy(start, limit, dest);
     }
 };

 const char TestReplaceable::fgClassID=0;

 const UChar TestReplaceable::NO_STYLE  = 0x005F;

 const UChar TestReplaceable::NO_STYLE_MARK = 0xFFFF;

 void
 ReplaceableTest::runIndexedTest(int32_t index, UBool exec,
                                       const char* &name, char* /*par*/) {
     switch (index) {
         TESTCASE(0,TestReplaceableClass);
         default: name = ""; break;
     }
 }

 /*
  * Dummy Replaceable implementation for better API/code coverage.
  */
 class NoopReplaceable : public Replaceable {
 public:
     virtual int32_t getLength() const {
         return 0;
     }

     virtual UChar getCharAt(int32_t /*offset*/) const{
         return 0xffff;
     }

     virtual UChar32 getChar32At(int32_t /*offset*/) const{
         return 0xffff;
     }

     void extractBetween(int32_t /*start*/, int32_t /*limit*/, UnicodeString& result) const {
         result.remove();
     }

     virtual void handleReplaceBetween(int32_t /*start*/, int32_t /*limit*/, const UnicodeString &/*text*/) {
         /* do nothing */
     }

     virtual void copy(int32_t /*start*/, int32_t /*limit*/, int32_t /*dest*/) {
         /* do nothing */
     }

     static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
     virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }

 private:
     static const char fgClassID;
 };

 const char NoopReplaceable::fgClassID=0;

 void ReplaceableTest::TestReplaceableClass(void) {
     UChar rawTestArray[][6] = {
         {0x0041, 0x0042, 0x0043, 0x0044, 0x0000, 0x0000}, // ABCD
         {0x0061, 0x0062, 0x0063, 0x0064, 0x00DF, 0x0000}, // abcd\u00DF
         {0x0061, 0x0042, 0x0043, 0x0044, 0x0000, 0x0000}, // aBCD
         {0x0041, 0x0300, 0x0045, 0x0300, 0x0000, 0x0000}, // A\u0300E\u0300
         {0x00C0, 0x00C8, 0x0000, 0x0000, 0x0000, 0x0000}, // \u00C0\u00C8
         {0x0077, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "wxy" */
         {0x0077, 0x0078, 0x0079, 0x007A, 0x0000, 0x0000}, /* "wxyz" */
         {0x0077, 0x0078, 0x0079, 0x007A, 0x0075, 0x0000}, /* "wxyzu" */
         {0x0078, 0x0079, 0x007A, 0x0000, 0x0000, 0x0000}, /* "xyz" */
         {0x0077, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "wxy" */
         {0xFFFF, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "*xy" */
         {0xFFFF, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "*xy" */
     };
     check("Lower", rawTestArray[0], "1234");
     check("Upper", rawTestArray[1], "123455"); // must map 00DF to SS
     check("Title", rawTestArray[2], "1234");
     check("NFC",   rawTestArray[3], "13");
     check("NFD",   rawTestArray[4], "1122");
     check("*(x) > A $1 B", rawTestArray[5], "11223");
     check("*(x)(y) > A $2 B $1 C $2 D", rawTestArray[6], "113322334");
     check("*(x)(y)(z) > A $3 B $2 C $1 D", rawTestArray[7], "114433225");
     // Disabled for 2.4.  TODO Revisit in 2.6 or later.
     //check("*x > a", rawTestArray[8], "223"); // expect "123"?
     //check("*x > a", rawTestArray[9], "113"); // expect "123"?
     //check("*x > a", rawTestArray[10], "_33"); // expect "_23"?
     //check("*(x) > A $1 B", rawTestArray[11], "__223");

     // improve API/code coverage
     NoopReplaceable noop;
     Replaceable *p;
     if((p=noop.clone())!=NULL) {
         errln("Replaceable::clone() does not return NULL");
         delete p;
     }

     if(!noop.hasMetaData()) {
         errln("Replaceable::hasMetaData() does not return TRUE");
     }

     // try to call the compiler-provided
     // UMemory/UObject/Replaceable assignment operators
     NoopReplaceable noop2;
     noop2=noop;
     if((p=noop2.clone())!=NULL) {
         errln("noop2.Replaceable::clone() does not return NULL");
         delete p;
     }

     // try to call the compiler-provided
     // UMemory/UObject/Replaceable copy constructors
     NoopReplaceable noop3(noop);
     if((p=noop3.clone())!=NULL) {
         errln("noop3.Replaceable::clone() does not return NULL");
         delete p;
     }
 }

 void ReplaceableTest::check(const UnicodeString& transliteratorName,
                             const UnicodeString& test,
                             const UnicodeString& shouldProduceStyles)
 {
     UErrorCode status = U_ZERO_ERROR;
     TestReplaceable *tr = new TestReplaceable(test, "");
     UnicodeString expectedStyles = shouldProduceStyles;
     UnicodeString original = tr->toString();

     Transliterator* t;
     if (transliteratorName.charAt(0) == 0x2A /*'*'*/) {
         UnicodeString rules(transliteratorName);
         rules.remove(0,1);
         UParseError pe;
         t = Transliterator::createFromRules("test", rules, UTRANS_FORWARD,
                                             pe, status);

         // test clone()
         TestReplaceable *tr2 = (TestReplaceable *)tr->clone();
         if(tr2 != NULL) {
             delete tr;
             tr = tr2;
         }
     } else {
         t = Transliterator::createInstance(transliteratorName, UTRANS_FORWARD, status);
     }
     if (U_FAILURE(status)) {
         dataerrln("FAIL: failed to create the " + transliteratorName + " transliterator");
         delete tr;
         return;
     }
     t->transliterate(*tr);
     UnicodeString newStyles = tr->getStyles();
     if (newStyles != expectedStyles) {
         errln("FAIL Styles: " + transliteratorName + "{" + original + "} => "
             + tr->toString() + "; should be {" + expectedStyles + "}!");
     } else {
         log("OK: ");
         log(transliteratorName);
         log("(");
         log(original);
         log(") => ");
         logln(tr->toString());
     }
     delete tr;
     delete t;
 }

 #endif /* #if !UCONFIG_NO_TRANSLITERATION */
	/********************************************************************
	* COPYRIGHT:
	* Copyright (c) 2001-2010, International Business Machines Corporation and
	* others. All Rights Reserved.
	********************************************************************/
	/************************************************************************
	* This test program is intended for testing Replaceable class.
	*
	* Date Name Description
	* 11/28/2001 hshih Ported back from Java.
	*
	************************************************************************/

	#include "unicode/utypes.h"

	#if !UCONFIG_NO_TRANSLITERATION

	#include "ittrans.h"
	#include <string.h>
	#include <stdio.h>
	#include <stdlib.h>
	#include "unicode/rep.h"
	#include "reptest.h"

	//---------------------------------------------
	// runIndexedTest
	//---------------------------------------------

	/**
	* This is a test class that simulates styled text.
	* It associates a style number (0..65535) with each character,
	* and maintains that style in the normal fashion:
	* When setting text from raw string or characters,<br>
	* Set the styles to the style of the first character replaced.<br>
	* If no characters are replaced, use the style of the previous character.<br>
	* If at start, use the following character<br>
	* Otherwise use NO_STYLE.
	*/
	class TestReplaceable : public Replaceable {
	UnicodeString chars;
	UnicodeString styles;

	static const UChar NO_STYLE;

	static const UChar NO_STYLE_MARK;

	/**
	* The address of this static class variable serves as this class's ID
	* for ICU "poor man's RTTI".
	*/
	static const char fgClassID;

	public:
	TestReplaceable (const UnicodeString& text,
	const UnicodeString& newStyles) {
	chars = text;
	UnicodeString s;
	for (int i = 0; i < text.length(); ++i) {
	if (i < newStyles.length()) {
	s.append(newStyles.charAt(i));
	} else {
	if (text.charAt(i) == NO_STYLE_MARK) {
	s.append(NO_STYLE);
	} else {
	s.append((UChar)(i + 0x0031));
	}
	}
	}
	this->styles = s;
	}

	virtual Replaceable *clone() const {
	return new TestReplaceable(chars, styles);
	}

	~TestReplaceable(void) {}

	UnicodeString getStyles() {
	return styles;
	}

	UnicodeString toString() {
	UnicodeString s = chars;
	s.append("{");
	s.append(styles);
	s.append("}");
	return s;
	}

	void extractBetween(int32_t start, int32_t limit, UnicodeString& result) const {
	chars.extractBetween(start, limit, result);
	}

	/**
	* ICU "poor man's RTTI", returns a UClassID for this class.
	*
	* @draft ICU 2.2
	*/
	static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }

	/**
	* ICU "poor man's RTTI", returns a UClassID for the actual class.
	*
	* @draft ICU 2.2
	*/
	virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }

	protected:
	virtual int32_t getLength() const {
	return chars.length();
	}

	virtual UChar getCharAt(int32_t offset) const{
	return chars.charAt(offset);
	}

	virtual UChar32 getChar32At(int32_t offset) const{
	return chars.char32At(offset);
	}

	void fixStyles(int32_t start, int32_t limit, int32_t newLen) {
	UChar newStyle = NO_STYLE;
	if (start != limit && styles.charAt(start) != NO_STYLE) {
	newStyle = styles.charAt(start);
	} else if (start > 0 && getCharAt(start-1) != NO_STYLE_MARK) {
	newStyle = styles.charAt(start-1);
	} else if (limit < styles.length()) {
	newStyle = styles.charAt(limit);
	}
	// dumb implementation for now.
	UnicodeString s;
	for (int i = 0; i < newLen; ++i) {
	// this doesn't really handle an embedded NO_STYLE_MARK
	// in the middle of a long run of characters right -- but
	// that case shouldn't happen anyway
	if (getCharAt(start+i) == NO_STYLE_MARK) {
	s.append(NO_STYLE);
	} else {
	s.append(newStyle);
	}
	}
	styles.replaceBetween(start, limit, s);
	}

	virtual void handleReplaceBetween(int32_t start, int32_t limit, const UnicodeString& text) {
	UnicodeString s;
	this->extractBetween(start, limit, s);
	if (s == text) return; // NO ACTION!
	this->chars.replaceBetween(start, limit, text);
	fixStyles(start, limit, text.length());
	}


	virtual void copy(int32_t start, int32_t limit, int32_t dest) {
	chars.copy(start, limit, dest);
	styles.copy(start, limit, dest);
	}
	};

	const char TestReplaceable::fgClassID=0;

	const UChar TestReplaceable::NO_STYLE = 0x005F;

	const UChar TestReplaceable::NO_STYLE_MARK = 0xFFFF;

	void
	ReplaceableTest::runIndexedTest(int32_t index, UBool exec,
	const char* &name, char* /par/) {
	switch (index) {
	TESTCASE(0,TestReplaceableClass);
	default: name = ""; break;
	}
	}

	/*
	* Dummy Replaceable implementation for better API/code coverage.
	*/
	class NoopReplaceable : public Replaceable {
	public:
	virtual int32_t getLength() const {
	return 0;
	}

	virtual UChar getCharAt(int32_t /offset/) const{
	return 0xffff;
	}

	virtual UChar32 getChar32At(int32_t /offset/) const{
	return 0xffff;
	}

	void extractBetween(int32_t /start/, int32_t /limit/, UnicodeString& result) const {
	result.remove();
	}

	virtual void handleReplaceBetween(int32_t /start/, int32_t /limit/, const UnicodeString &/text/) {
	/* do nothing */
	}

	virtual void copy(int32_t /start/, int32_t /limit/, int32_t /dest/) {
	/* do nothing */
	}

	static inline UClassID getStaticClassID() { return (UClassID)&fgClassID; }
	virtual inline UClassID getDynamicClassID() const { return getStaticClassID(); }

	private:
	static const char fgClassID;
	};

	const char NoopReplaceable::fgClassID=0;

	void ReplaceableTest::TestReplaceableClass(void) {
	UChar rawTestArray[][6] = {
	{0x0041, 0x0042, 0x0043, 0x0044, 0x0000, 0x0000}, // ABCD
	{0x0061, 0x0062, 0x0063, 0x0064, 0x00DF, 0x0000}, // abcd\u00DF
	{0x0061, 0x0042, 0x0043, 0x0044, 0x0000, 0x0000}, // aBCD
	{0x0041, 0x0300, 0x0045, 0x0300, 0x0000, 0x0000}, // A\u0300E\u0300
	{0x00C0, 0x00C8, 0x0000, 0x0000, 0x0000, 0x0000}, // \u00C0\u00C8
	{0x0077, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "wxy" */
	{0x0077, 0x0078, 0x0079, 0x007A, 0x0000, 0x0000}, /* "wxyz" */
	{0x0077, 0x0078, 0x0079, 0x007A, 0x0075, 0x0000}, /* "wxyzu" */
	{0x0078, 0x0079, 0x007A, 0x0000, 0x0000, 0x0000}, /* "xyz" */
	{0x0077, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "wxy" */
	{0xFFFF, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "xy" /
	{0xFFFF, 0x0078, 0x0079, 0x0000, 0x0000, 0x0000}, /* "xy" /
	};
	check("Lower", rawTestArray[0], "1234");
	check("Upper", rawTestArray[1], "123455"); // must map 00DF to SS
	check("Title", rawTestArray[2], "1234");
	check("NFC", rawTestArray[3], "13");
	check("NFD", rawTestArray[4], "1122");
	check("*(x) > A $1 B", rawTestArray[5], "11223");
	check("*(x)(y) > A $2 B $1 C $2 D", rawTestArray[6], "113322334");
	check("*(x)(y)(z) > A $3 B $2 C $1 D", rawTestArray[7], "114433225");
	// Disabled for 2.4. TODO Revisit in 2.6 or later.
	//check("*x > a", rawTestArray[8], "223"); // expect "123"?
	//check("*x > a", rawTestArray[9], "113"); // expect "123"?
	//check("*x > a", rawTestArray[10], "_33"); // expect "_23"?
	//check("*(x) > A $1 B", rawTestArray[11], "__223");

	// improve API/code coverage
	NoopReplaceable noop;
	Replaceable *p;
	if((p=noop.clone())!=NULL) {
	errln("Replaceable::clone() does not return NULL");
	delete p;
	}

	if(!noop.hasMetaData()) {
	errln("Replaceable::hasMetaData() does not return TRUE");
	}

	// try to call the compiler-provided
	// UMemory/UObject/Replaceable assignment operators
	NoopReplaceable noop2;
	noop2=noop;
	if((p=noop2.clone())!=NULL) {
	errln("noop2.Replaceable::clone() does not return NULL");
	delete p;
	}

	// try to call the compiler-provided
	// UMemory/UObject/Replaceable copy constructors
	NoopReplaceable noop3(noop);
	if((p=noop3.clone())!=NULL) {
	errln("noop3.Replaceable::clone() does not return NULL");
	delete p;
	}
	}

	void ReplaceableTest::check(const UnicodeString& transliteratorName,
	const UnicodeString& test,
	const UnicodeString& shouldProduceStyles)
	{
	UErrorCode status = U_ZERO_ERROR;
	TestReplaceable *tr = new TestReplaceable(test, "");
	UnicodeString expectedStyles = shouldProduceStyles;
	UnicodeString original = tr->toString();

	Transliterator* t;
	if (transliteratorName.charAt(0) == 0x2A /''*/) {
	UnicodeString rules(transliteratorName);
	rules.remove(0,1);
	UParseError pe;
	t = Transliterator::createFromRules("test", rules, UTRANS_FORWARD,
	pe, status);

	// test clone()
	TestReplaceable tr2 = (TestReplaceable )tr->clone();
	if(tr2 != NULL) {
	delete tr;
	tr = tr2;
	}
	} else {
	t = Transliterator::createInstance(transliteratorName, UTRANS_FORWARD, status);
	}
	if (U_FAILURE(status)) {
	dataerrln("FAIL: failed to create the " + transliteratorName + " transliterator");
	delete tr;
	return;
	}
	t->transliterate(*tr);
	UnicodeString newStyles = tr->getStyles();
	if (newStyles != expectedStyles) {
	errln("FAIL Styles: " + transliteratorName + "{" + original + "} => "
	+ tr->toString() + "; should be {" + expectedStyles + "}!");
	} else {
	log("OK: ");
	log(transliteratorName);
	log("(");
	log(original);
	log(") => ");
	logln(tr->toString());
	}
	delete tr;
	delete t;
	}

	#endif /* #if !UCONFIG_NO_TRANSLITERATION */