[apple/icu.git] / icuSources / test / intltest / strtest.cpp

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/********************************************************************
 * COPYRIGHT: 
 * Copyright (c) 1997-2015, International Business Machines Corporation and
 * others. All Rights Reserved.
 ********************************************************************/
/*   file name:  strtest.cpp
*   encoding:   UTF-8
*   tab size:   8 (not used)
*   indentation:4
*
*   created on: 1999nov22
*   created by: Markus W. Scherer
*/

#include <string.h>

#include "unicode/utypes.h"
#include "unicode/putil.h"
#include "unicode/std_string.h"
#include "unicode/stringpiece.h"
#include "unicode/unistr.h"
#include "unicode/ustring.h"
#include "unicode/utf_old.h"    // for UTF8_COUNT_TRAIL_BYTES
#include "unicode/utf8.h"
#include "charstr.h"
#include "cstr.h"
#include "intltest.h"
#include "strtest.h"

StringTest::~StringTest() {}

void StringTest::TestEndian(void) {
    union {
        uint8_t byte;
        uint16_t word;
    } u;
    u.word=0x0100;
    if(U_IS_BIG_ENDIAN!=u.byte) {
        errln("TestEndian: U_IS_BIG_ENDIAN needs to be fixed in platform.h");
    }
}

void StringTest::TestSizeofTypes(void) {
    if(U_SIZEOF_WCHAR_T!=sizeof(wchar_t)) {
        errln("TestSizeofWCharT: U_SIZEOF_WCHAR_T!=sizeof(wchar_t) - U_SIZEOF_WCHAR_T needs to be fixed in platform.h");
    }
#ifdef U_INT64_T_UNAVAILABLE
    errln("int64_t and uint64_t are undefined.");
#else
    if(8!=sizeof(int64_t)) {
        errln("TestSizeofTypes: 8!=sizeof(int64_t) - int64_t needs to be fixed in platform.h");
    }
    if(8!=sizeof(uint64_t)) {
        errln("TestSizeofTypes: 8!=sizeof(uint64_t) - uint64_t needs to be fixed in platform.h");
    }
#endif
    if(8!=sizeof(double)) {
        errln("8!=sizeof(double) - putil.c code may not work");
    }
    if(4!=sizeof(int32_t)) {
        errln("4!=sizeof(int32_t)");
    }
    if(4!=sizeof(uint32_t)) {
        errln("4!=sizeof(uint32_t)");
    }
    if(2!=sizeof(int16_t)) {
        errln("2!=sizeof(int16_t)");
    }
    if(2!=sizeof(uint16_t)) {
        errln("2!=sizeof(uint16_t)");
    }
    if(2!=sizeof(UChar)) {
        errln("2!=sizeof(UChar)");
    }
    if(1!=sizeof(int8_t)) {
        errln("1!=sizeof(int8_t)");
    }
    if(1!=sizeof(uint8_t)) {
        errln("1!=sizeof(uint8_t)");
    }
    if(1!=sizeof(UBool)) {
        errln("1!=sizeof(UBool)");
    }
}

void StringTest::TestCharsetFamily(void) {
    unsigned char c='A';
    if( (U_CHARSET_FAMILY==U_ASCII_FAMILY && c!=0x41) ||
        (U_CHARSET_FAMILY==U_EBCDIC_FAMILY && c!=0xc1)
    ) {
        errln("TestCharsetFamily: U_CHARSET_FAMILY needs to be fixed in platform.h");
    }
}

U_STRING_DECL(ustringVar, "aZ0 -", 5);

void
StringTest::Test_U_STRING() {
    U_STRING_INIT(ustringVar, "aZ0 -", 5);
    if( u_strlen(ustringVar)!=5 ||
        ustringVar[0]!=0x61 ||
        ustringVar[1]!=0x5a ||
        ustringVar[2]!=0x30 ||
        ustringVar[3]!=0x20 ||
        ustringVar[4]!=0x2d ||
        ustringVar[5]!=0
    ) {
        errln("Test_U_STRING: U_STRING_DECL with U_STRING_INIT does not work right! "
              "See putil.h and utypes.h with platform.h.");
    }
}

void
StringTest::Test_UNICODE_STRING() {
    UnicodeString ustringVar=UNICODE_STRING("aZ0 -", 5);
    if( ustringVar.length()!=5 ||
        ustringVar[0]!=0x61 ||
        ustringVar[1]!=0x5a ||
        ustringVar[2]!=0x30 ||
        ustringVar[3]!=0x20 ||
        ustringVar[4]!=0x2d
    ) {
        errln("Test_UNICODE_STRING: UNICODE_STRING does not work right! "
              "See unistr.h and utypes.h with platform.h.");
    }
}

void
StringTest::Test_UNICODE_STRING_SIMPLE() {
    UnicodeString ustringVar=UNICODE_STRING_SIMPLE("aZ0 -");
    if( ustringVar.length()!=5 ||
        ustringVar[0]!=0x61 ||
        ustringVar[1]!=0x5a ||
        ustringVar[2]!=0x30 ||
        ustringVar[3]!=0x20 ||
        ustringVar[4]!=0x2d
    ) {
        errln("Test_UNICODE_STRING_SIMPLE: UNICODE_STRING_SIMPLE does not work right! "
              "See unistr.h and utypes.h with platform.h.");
    }
}

void
StringTest::Test_UTF8_COUNT_TRAIL_BYTES() {
#if !U_HIDE_OBSOLETE_UTF_OLD_H
    if(UTF8_COUNT_TRAIL_BYTES(0x7F) != 0
            || UTF8_COUNT_TRAIL_BYTES(0xC2) != 1
            || UTF8_COUNT_TRAIL_BYTES(0xE0) != 2
            || UTF8_COUNT_TRAIL_BYTES(0xF0) != 3) {
        errln("UTF8_COUNT_TRAIL_BYTES does not work right! See utf_old.h.");
    }
#endif
    // Note: U8_COUNT_TRAIL_BYTES (current) and UTF8_COUNT_TRAIL_BYTES (deprecated)
    //       have completely different implementations.
    if (U8_COUNT_TRAIL_BYTES(0x7F) != 0
            || U8_COUNT_TRAIL_BYTES(0xC2) != 1
            || U8_COUNT_TRAIL_BYTES(0xE0) != 2
            || U8_COUNT_TRAIL_BYTES(0xF0) != 3) {
        errln("U8_COUNT_TRAIL_BYTES does not work right! See utf8.h.");
    }
}

void StringTest::runIndexedTest(int32_t index, UBool exec, const char *&name, char * /*par*/) {
    if(exec) {
        logln("TestSuite Character and String Test: ");
    }
    TESTCASE_AUTO_BEGIN;
    TESTCASE_AUTO(TestEndian);
    TESTCASE_AUTO(TestSizeofTypes);
    TESTCASE_AUTO(TestCharsetFamily);
    TESTCASE_AUTO(Test_U_STRING);
    TESTCASE_AUTO(Test_UNICODE_STRING);
    TESTCASE_AUTO(Test_UNICODE_STRING_SIMPLE);
    TESTCASE_AUTO(Test_UTF8_COUNT_TRAIL_BYTES);
    TESTCASE_AUTO(TestSTLCompatibility);
    TESTCASE_AUTO(TestStringPiece);
    TESTCASE_AUTO(TestStringPieceComparisons);
    TESTCASE_AUTO(TestByteSink);
    TESTCASE_AUTO(TestCheckedArrayByteSink);
    TESTCASE_AUTO(TestStringByteSink);
    TESTCASE_AUTO(TestCharString);
    TESTCASE_AUTO(TestCStr);
    TESTCASE_AUTO(Testctou);
    TESTCASE_AUTO_END;
}

void
StringTest::TestStringPiece() {
    // Default constructor.
    StringPiece empty;
    if(!empty.empty() || empty.data()!=NULL || empty.length()!=0 || empty.size()!=0) {
        errln("StringPiece() failed");
    }
    // Construct from NULL const char * pointer.
    StringPiece null(NULL);
    if(!null.empty() || null.data()!=NULL || null.length()!=0 || null.size()!=0) {
        errln("StringPiece(NULL) failed");
    }
    // Construct from const char * pointer.
    static const char *abc_chars="abc";
    StringPiece abc(abc_chars);
    if(abc.empty() || abc.data()!=abc_chars || abc.length()!=3 || abc.size()!=3) {
        errln("StringPiece(abc_chars) failed");
    }
    // Construct from const char * pointer and length.
    static const char *abcdefg_chars="abcdefg";
    StringPiece abcd(abcdefg_chars, 4);
    if(abcd.empty() || abcd.data()!=abcdefg_chars || abcd.length()!=4 || abcd.size()!=4) {
        errln("StringPiece(abcdefg_chars, 4) failed");
    }
    // Construct from std::string.
    std::string uvwxyz_string("uvwxyz");
    StringPiece uvwxyz(uvwxyz_string);
    if(uvwxyz.empty() || uvwxyz.data()!=uvwxyz_string.data() || uvwxyz.length()!=6 || uvwxyz.size()!=6) {
        errln("StringPiece(uvwxyz_string) failed");
    }
    // Substring constructor with pos.
    StringPiece sp(abcd, -1);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("StringPiece(abcd, -1) failed");
    }
    sp=StringPiece(abcd, 5);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("StringPiece(abcd, 5) failed");
    }
    sp=StringPiece(abcd, 2);
    if(sp.empty() || sp.data()!=abcdefg_chars+2 || sp.length()!=2 || sp.size()!=2) {
        errln("StringPiece(abcd, -1) failed");
    }
    // Substring constructor with pos and len.
    sp=StringPiece(abcd, -1, 8);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("StringPiece(abcd, -1, 8) failed");
    }
    sp=StringPiece(abcd, 5, 8);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("StringPiece(abcd, 5, 8) failed");
    }
    sp=StringPiece(abcd, 2, 8);
    if(sp.empty() || sp.data()!=abcdefg_chars+2 || sp.length()!=2 || sp.size()!=2) {
        errln("StringPiece(abcd, -1) failed");
    }
    sp=StringPiece(abcd, 2, -1);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("StringPiece(abcd, 5, -1) failed");
    }
    // static const npos
    const int32_t *ptr_npos=&StringPiece::npos;
    if(StringPiece::npos!=0x7fffffff || *ptr_npos!=0x7fffffff) {
        errln("StringPiece::npos!=0x7fffffff");
    }
    // substr() method with pos, using len=npos.
    sp=abcd.substr(-1);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("abcd.substr(-1) failed");
    }
    sp=abcd.substr(5);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.substr(5) failed");
    }
    sp=abcd.substr(2);
    if(sp.empty() || sp.data()!=abcdefg_chars+2 || sp.length()!=2 || sp.size()!=2) {
        errln("abcd.substr(-1) failed");
    }
    // substr() method with pos and len.
    sp=abcd.substr(-1, 8);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("abcd.substr(-1, 8) failed");
    }
    sp=abcd.substr(5, 8);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.substr(5, 8) failed");
    }
    sp=abcd.substr(2, 8);
    if(sp.empty() || sp.data()!=abcdefg_chars+2 || sp.length()!=2 || sp.size()!=2) {
        errln("abcd.substr(-1) failed");
    }
    sp=abcd.substr(2, -1);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.substr(5, -1) failed");
    }
    // clear()
    sp=abcd;
    sp.clear();
    if(!sp.empty() || sp.data()!=NULL || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.clear() failed");
    }
    // remove_prefix()
    sp=abcd;
    sp.remove_prefix(-1);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("abcd.remove_prefix(-1) failed");
    }
    sp=abcd;
    sp.remove_prefix(2);
    if(sp.empty() || sp.data()!=abcdefg_chars+2 || sp.length()!=2 || sp.size()!=2) {
        errln("abcd.remove_prefix(2) failed");
    }
    sp=abcd;
    sp.remove_prefix(5);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.remove_prefix(5) failed");
    }
    // remove_suffix()
    sp=abcd;
    sp.remove_suffix(-1);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=4 || sp.size()!=4) {
        errln("abcd.remove_suffix(-1) failed");
    }
    sp=abcd;
    sp.remove_suffix(2);
    if(sp.empty() || sp.data()!=abcdefg_chars || sp.length()!=2 || sp.size()!=2) {
        errln("abcd.remove_suffix(2) failed");
    }
    sp=abcd;
    sp.remove_suffix(5);
    if(!sp.empty() || sp.length()!=0 || sp.size()!=0) {
        errln("abcd.remove_suffix(5) failed");
    }
}

void
StringTest::TestStringPieceComparisons() {
    StringPiece empty;
    StringPiece null(NULL);
    StringPiece abc("abc");
    StringPiece abcd("abcdefg", 4);
    StringPiece abx("abx");
    if(empty!=null) {
        errln("empty!=null");
    }
    if(empty==abc) {
        errln("empty==abc");
    }
    if(abc==abcd) {
        errln("abc==abcd");
    }
    abcd.remove_suffix(1);
    if(abc!=abcd) {
        errln("abc!=abcd.remove_suffix(1)");
    }
    if(abc==abx) {
        errln("abc==abx");
    }
}

// Verify that ByteSink is subclassable and Flush() overridable.
class SimpleByteSink : public ByteSink {
public:
    SimpleByteSink(char *outbuf) : fOutbuf(outbuf), fLength(0) {}
    virtual void Append(const char *bytes, int32_t n) {
        if(fOutbuf != bytes) {
            memcpy(fOutbuf, bytes, n);
        }
        fOutbuf += n;
        fLength += n;
    }
    virtual void Flush() { Append("z", 1); }
    int32_t length() { return fLength; }
private:
    char *fOutbuf;
    int32_t fLength;
};

// Test the ByteSink base class.
void
StringTest::TestByteSink() {
    char buffer[20];
    buffer[4] = '!';
    SimpleByteSink sink(buffer);
    sink.Append("abc", 3);
    sink.Flush();
    if(!(sink.length() == 4 && 0 == memcmp("abcz", buffer, 4) && buffer[4] == '!')) {
        errln("ByteSink (SimpleByteSink) did not Append() or Flush() as expected");
        return;
    }
    char scratch[20];
    int32_t capacity = -1;
    char *dest = sink.GetAppendBuffer(0, 50, scratch, (int32_t)sizeof(scratch), &capacity);
    if(dest != NULL || capacity != 0) {
        errln("ByteSink.GetAppendBuffer(min_capacity<1) did not properly return NULL[0]");
        return;
    }
    dest = sink.GetAppendBuffer(10, 50, scratch, 9, &capacity);
    if(dest != NULL || capacity != 0) {
        errln("ByteSink.GetAppendBuffer(scratch_capacity<min_capacity) did not properly return NULL[0]");
        return;
    }
    dest = sink.GetAppendBuffer(5, 50, scratch, (int32_t)sizeof(scratch), &capacity);
    if(dest != scratch || capacity != (int32_t)sizeof(scratch)) {
        errln("ByteSink.GetAppendBuffer() did not properly return the scratch buffer");
    }
}

void
StringTest::TestCheckedArrayByteSink() {
    char buffer[20];  // < 26 for the test code to work
    buffer[3] = '!';
    CheckedArrayByteSink sink(buffer, (int32_t)sizeof(buffer));
    sink.Append("abc", 3);
    if(!(sink.NumberOfBytesAppended() == 3 && sink.NumberOfBytesWritten() == 3 &&
         0 == memcmp("abc", buffer, 3) && buffer[3] == '!') &&
         !sink.Overflowed()
    ) {
        errln("CheckedArrayByteSink did not Append() as expected");
        return;
    }
    char scratch[10];
    int32_t capacity = -1;
    char *dest = sink.GetAppendBuffer(0, 50, scratch, (int32_t)sizeof(scratch), &capacity);
    if(dest != NULL || capacity != 0) {
        errln("CheckedArrayByteSink.GetAppendBuffer(min_capacity<1) did not properly return NULL[0]");
        return;
    }
    dest = sink.GetAppendBuffer(10, 50, scratch, 9, &capacity);
    if(dest != NULL || capacity != 0) {
        errln("CheckedArrayByteSink.GetAppendBuffer(scratch_capacity<min_capacity) did not properly return NULL[0]");
        return;
    }
    dest = sink.GetAppendBuffer(10, 50, scratch, (int32_t)sizeof(scratch), &capacity);
    if(dest != buffer + 3 || capacity != (int32_t)sizeof(buffer) - 3) {
        errln("CheckedArrayByteSink.GetAppendBuffer() did not properly return its own buffer");
        return;
    }
    memcpy(dest, "defghijklm", 10);
    sink.Append(dest, 10);
    if(!(sink.NumberOfBytesAppended() == 13 && sink.NumberOfBytesWritten() == 13 &&
         0 == memcmp("abcdefghijklm", buffer, 13) &&
         !sink.Overflowed())
    ) {
        errln("CheckedArrayByteSink did not Append(its own buffer) as expected");
        return;
    }
    dest = sink.GetAppendBuffer(10, 50, scratch, (int32_t)sizeof(scratch), &capacity);
    if(dest != scratch || capacity != (int32_t)sizeof(scratch)) {
        errln("CheckedArrayByteSink.GetAppendBuffer() did not properly return the scratch buffer");
    }
    memcpy(dest, "nopqrstuvw", 10);
    sink.Append(dest, 10);
    if(!(sink.NumberOfBytesAppended() == 23 &&
         sink.NumberOfBytesWritten() == (int32_t)sizeof(buffer) &&
         0 == memcmp("abcdefghijklmnopqrstuvwxyz", buffer, (int32_t)sizeof(buffer)) &&
         sink.Overflowed())
    ) {
        errln("CheckedArrayByteSink did not Append(scratch buffer) as expected");
        return;
    }
    sink.Reset().Append("123", 3);
    if(!(sink.NumberOfBytesAppended() == 3 && sink.NumberOfBytesWritten() == 3 &&
         0 == memcmp("123defghijklmnopqrstuvwxyz", buffer, (int32_t)sizeof(buffer)) &&
         !sink.Overflowed())
    ) {
        errln("CheckedArrayByteSink did not Reset().Append() as expected");
        return;
    }
}

void
StringTest::TestStringByteSink() {
    // Not much to test because only the constructors and Append()
    // are implemented, and trivially so.
    std::string result("abc");  // std::string
    StringByteSink<std::string> sink(&result);
    sink.Append("def", 3);
    if(result != "abcdef") {
        errln("StringByteSink did not Append() as expected");
    }
    StringByteSink<std::string> sink2(&result, 20);
    if(result.capacity() < (result.length() + 20)) {
        errln("StringByteSink should have 20 append capacity, has only %d",
              (int)(result.capacity() - result.length()));
    }
    sink.Append("ghi", 3);
    if(result != "abcdefghi") {
        errln("StringByteSink did not Append() as expected");
    }
}

#if defined(_MSC_VER)
#include <vector>
#endif

void
StringTest::TestSTLCompatibility() {
#if defined(_MSC_VER)
    /* Just make sure that it compiles with STL's placement new usage. */
    std::vector<UnicodeString> myvect;
    myvect.push_back(UnicodeString("blah"));
#endif
}

void
StringTest::TestCharString() {
    IcuTestErrorCode errorCode(*this, "TestCharString()");
    char expected[400];
    static const char longStr[] =
        "This is a long string that is meant to cause reallocation of the internal buffer of CharString.";
    CharString chStr(longStr, errorCode);
    if (0 != strcmp(longStr, chStr.data()) || (int32_t)strlen(longStr) != chStr.length()) {
        errln("CharString(longStr) failed.");
    }
    CharString test("Test", errorCode);
    CharString copy(test,errorCode);
    copy.copyFrom(chStr, errorCode);
    if (0 != strcmp(longStr, copy.data()) || (int32_t)strlen(longStr) != copy.length()) {
        errln("CharString.copyFrom() failed.");
    }
    StringPiece sp(chStr.toStringPiece());
    sp.remove_prefix(4);
    chStr.append(sp, errorCode).append(chStr, errorCode);
    strcpy(expected, longStr);
    strcat(expected, longStr+4);
    strcat(expected, longStr);
    strcat(expected, longStr+4);
    if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
        errln("CharString(longStr).append(substring of self).append(self) failed.");
    }
    chStr.clear().append("abc", errorCode).append("defghij", 3, errorCode);
    if (0 != strcmp("abcdef", chStr.data()) || 6 != chStr.length()) {
        errln("CharString.clear().append(abc).append(defghij, 3) failed.");
    }
    chStr.appendInvariantChars(UNICODE_STRING_SIMPLE(
        "This is a long string that is meant to cause reallocation of the internal buffer of CharString."),
        errorCode);
    strcpy(expected, "abcdef");
    strcat(expected, longStr);
    if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
        errln("CharString.appendInvariantChars(longStr) failed.");
    }
    int32_t appendCapacity = 0;
    char *buffer = chStr.getAppendBuffer(5, 10, appendCapacity, errorCode);
    if (errorCode.isFailure()) {
        return;
    }
    memcpy(buffer, "*****", 5);
    chStr.append(buffer, 5, errorCode);
    chStr.truncate(chStr.length()-3);
    strcat(expected, "**");
    if (0 != strcmp(expected, chStr.data()) || (int32_t)strlen(expected) != chStr.length()) {
        errln("CharString.getAppendBuffer().append(**) failed.");
    }

    UErrorCode ec = U_ZERO_ERROR;
    chStr.clear();
    chStr.appendInvariantChars(UnicodeString("The '@' character is not invariant."), ec);
    if (ec != U_INVARIANT_CONVERSION_ERROR) {
        errln("%s:%d expected U_INVARIANT_CONVERSION_ERROR, got %s", __FILE__, __LINE__, u_errorName(ec));
    }
    if (chStr.length() != 0) {
        errln("%s:%d expected length() = 0, got %d", __FILE__, __LINE__, chStr.length());
    }

    {
        CharString s1("Short string", errorCode);
        CharString s2(std::move(s1));
        assertEquals("s2 should have content of s1", "Short string", s2.data());
        CharString s3("Dummy", errorCode);
        s3 = std::move(s2);
        assertEquals("s3 should have content of s2", "Short string", s3.data());
    }

    {
        CharString s1("Long string over 40 characters to trigger heap allocation", errorCode);
        CharString s2(std::move(s1));
        assertEquals("s2 should have content of s1",
                "Long string over 40 characters to trigger heap allocation",
                s2.data());
        CharString s3("Dummy string with over 40 characters to trigger heap allocation", errorCode);
        s3 = std::move(s2);
        assertEquals("s3 should have content of s2",
                "Long string over 40 characters to trigger heap allocation",
                s3.data());
    }
}

void
StringTest::TestCStr() {
    const char *cs = "This is a test string.";
    UnicodeString us(cs);
    if (0 != strcmp(CStr(us)(), cs)) {
        errln("%s:%d CStr(s)() failed. Expected \"%s\", got \"%s\"", __FILE__, __LINE__, cs, CStr(us)());
    }
}

void
StringTest::Testctou() {
  const char *cs = "Fa\\u0127mu";
  UnicodeString u = ctou(cs);
  assertEquals("Testing unescape@0", (int32_t)0x0046, u.charAt(0));
  assertEquals("Testing unescape@2", (int32_t)295, u.charAt(2));
}
Commit	Line	Data
f3c0d7a5 A	1	// © 2016 and later: Unicode, Inc. and others.
f3c0d7a5 A	2	// License & terms of use: http://www.unicode.org/copyright.html
b75a7d8f A	3	/********************************************************************
b75a7d8f A	4	* COPYRIGHT:
2ca993e8	5	* Copyright (c) 1997-2015, International Business Machines Corporation and
b75a7d8f A	6	* others. All Rights Reserved.
	7	********************************************************************/
	8	/* file name: strtest.cpp
f3c0d7a5	9	* encoding: UTF-8
b75a7d8f A	10	* tab size: 8 (not used)
	11	* indentation:4
	12	*
	13	* created on: 1999nov22
	14	* created by: Markus W. Scherer
	15	*/
	16
729e4ab9 A	17	#include <string.h>
729e4ab9 A	18
b75a7d8f A	19	#include "unicode/utypes.h"
b75a7d8f A	20	#include "unicode/putil.h"
729e4ab9 A	21	#include "unicode/std_string.h"
	22	#include "unicode/stringpiece.h"
	23	#include "unicode/unistr.h"
	24	#include "unicode/ustring.h"
f3c0d7a5 A	25	#include "unicode/utf_old.h" // for UTF8_COUNT_TRAIL_BYTES
f3c0d7a5 A	26	#include "unicode/utf8.h"
729e4ab9	27	#include "charstr.h"
2ca993e8	28	#include "cstr.h"
b75a7d8f A	29	#include "intltest.h"
b75a7d8f A	30	#include "strtest.h"
374ca955 A	31
	32	StringTest::~StringTest() {}
	33
b75a7d8f A	34	void StringTest::TestEndian(void) {
	35	union {
	36	uint8_t byte;
	37	uint16_t word;
	38	} u;
	39	u.word=0x0100;
	40	if(U_IS_BIG_ENDIAN!=u.byte) {
	41	errln("TestEndian: U_IS_BIG_ENDIAN needs to be fixed in platform.h");
	42	}
	43	}
	44
374ca955	45	void StringTest::TestSizeofTypes(void) {
b75a7d8f A	46	if(U_SIZEOF_WCHAR_T!=sizeof(wchar_t)) {
	47	errln("TestSizeofWCharT: U_SIZEOF_WCHAR_T!=sizeof(wchar_t) - U_SIZEOF_WCHAR_T needs to be fixed in platform.h");
	48	}
b75a7d8f A	49	#ifdef U_INT64_T_UNAVAILABLE
	50	errln("int64_t and uint64_t are undefined.");
	51	#else
	52	if(8!=sizeof(int64_t)) {
374ca955	53	errln("TestSizeofTypes: 8!=sizeof(int64_t) - int64_t needs to be fixed in platform.h");
b75a7d8f A	54	}
b75a7d8f A	55	if(8!=sizeof(uint64_t)) {
374ca955	56	errln("TestSizeofTypes: 8!=sizeof(uint64_t) - uint64_t needs to be fixed in platform.h");
b75a7d8f A	57	}
	58	#endif
	59	if(8!=sizeof(double)) {
	60	errln("8!=sizeof(double) - putil.c code may not work");
	61	}
374ca955 A	62	if(4!=sizeof(int32_t)) {
	63	errln("4!=sizeof(int32_t)");
	64	}
	65	if(4!=sizeof(uint32_t)) {
	66	errln("4!=sizeof(uint32_t)");
	67	}
	68	if(2!=sizeof(int16_t)) {
	69	errln("2!=sizeof(int16_t)");
	70	}
	71	if(2!=sizeof(uint16_t)) {
	72	errln("2!=sizeof(uint16_t)");
	73	}
	74	if(2!=sizeof(UChar)) {
	75	errln("2!=sizeof(UChar)");
	76	}
	77	if(1!=sizeof(int8_t)) {
	78	errln("1!=sizeof(int8_t)");
	79	}
	80	if(1!=sizeof(uint8_t)) {
	81	errln("1!=sizeof(uint8_t)");
	82	}
	83	if(1!=sizeof(UBool)) {
	84	errln("1!=sizeof(UBool)");
	85	}
b75a7d8f A	86	}
	87
	88	void StringTest::TestCharsetFamily(void) {
	89	unsigned char c='A';
729e4ab9 A	90	if( (U_CHARSET_FAMILY==U_ASCII_FAMILY && c!=0x41) \|\|
729e4ab9 A	91	(U_CHARSET_FAMILY==U_EBCDIC_FAMILY && c!=0xc1)
b75a7d8f A	92	) {
	93	errln("TestCharsetFamily: U_CHARSET_FAMILY needs to be fixed in platform.h");
	94	}
	95	}
	96
	97	U_STRING_DECL(ustringVar, "aZ0 -", 5);
	98
729e4ab9 A	99	void
	100	StringTest::Test_U_STRING() {
	101	U_STRING_INIT(ustringVar, "aZ0 -", 5);
51004dcb	102	if( u_strlen(ustringVar)!=5 \|\|
729e4ab9 A	103	ustringVar[0]!=0x61 \|\|
	104	ustringVar[1]!=0x5a \|\|
	105	ustringVar[2]!=0x30 \|\|
	106	ustringVar[3]!=0x20 \|\|
	107	ustringVar[4]!=0x2d \|\|
	108	ustringVar[5]!=0
	109	) {
	110	errln("Test_U_STRING: U_STRING_DECL with U_STRING_INIT does not work right! "
	111	"See putil.h and utypes.h with platform.h.");
	112	}
	113	}
	114
	115	void
	116	StringTest::Test_UNICODE_STRING() {
	117	UnicodeString ustringVar=UNICODE_STRING("aZ0 -", 5);
	118	if( ustringVar.length()!=5 \|\|
	119	ustringVar[0]!=0x61 \|\|
	120	ustringVar[1]!=0x5a \|\|
	121	ustringVar[2]!=0x30 \|\|
	122	ustringVar[3]!=0x20 \|\|
	123	ustringVar[4]!=0x2d
	124	) {
	125	errln("Test_UNICODE_STRING: UNICODE_STRING does not work right! "
	126	"See unistr.h and utypes.h with platform.h.");
	127	}
	128	}
	129
	130	void
	131	StringTest::Test_UNICODE_STRING_SIMPLE() {
	132	UnicodeString ustringVar=UNICODE_STRING_SIMPLE("aZ0 -");
	133	if( ustringVar.length()!=5 \|\|
	134	ustringVar[0]!=0x61 \|\|
	135	ustringVar[1]!=0x5a \|\|
	136	ustringVar[2]!=0x30 \|\|
	137	ustringVar[3]!=0x20 \|\|
	138	ustringVar[4]!=0x2d
	139	) {
	140	errln("Test_UNICODE_STRING_SIMPLE: UNICODE_STRING_SIMPLE does not work right! "
	141	"See unistr.h and utypes.h with platform.h.");
	142	}
	143	}
	144
	145	void
	146	StringTest::Test_UTF8_COUNT_TRAIL_BYTES() {
0f5d89e8	147	#if !U_HIDE_OBSOLETE_UTF_OLD_H
729e4ab9	148	if(UTF8_COUNT_TRAIL_BYTES(0x7F) != 0
0f5d89e8 A	149	\|\| UTF8_COUNT_TRAIL_BYTES(0xC2) != 1
	150	\|\| UTF8_COUNT_TRAIL_BYTES(0xE0) != 2
	151	\|\| UTF8_COUNT_TRAIL_BYTES(0xF0) != 3) {
	152	errln("UTF8_COUNT_TRAIL_BYTES does not work right! See utf_old.h.");
	153	}
	154	#endif
	155	// Note: U8_COUNT_TRAIL_BYTES (current) and UTF8_COUNT_TRAIL_BYTES (deprecated)
	156	// have completely different implementations.
	157	if (U8_COUNT_TRAIL_BYTES(0x7F) != 0
	158	\|\| U8_COUNT_TRAIL_BYTES(0xC2) != 1
	159	\|\| U8_COUNT_TRAIL_BYTES(0xE0) != 2
	160	\|\| U8_COUNT_TRAIL_BYTES(0xF0) != 3) {
	161	errln("U8_COUNT_TRAIL_BYTES does not work right! See utf8.h.");
	162	}
729e4ab9 A	163	}
729e4ab9 A	164
b75a7d8f A	165	void StringTest::runIndexedTest(int32_t index, UBool exec, const char &name, char /par/) {
	166	if(exec) {
	167	logln("TestSuite Character and String Test: ");
	168	}
729e4ab9 A	169	TESTCASE_AUTO_BEGIN;
	170	TESTCASE_AUTO(TestEndian);
	171	TESTCASE_AUTO(TestSizeofTypes);
	172	TESTCASE_AUTO(TestCharsetFamily);
	173	TESTCASE_AUTO(Test_U_STRING);
	174	TESTCASE_AUTO(Test_UNICODE_STRING);
	175	TESTCASE_AUTO(Test_UNICODE_STRING_SIMPLE);
	176	TESTCASE_AUTO(Test_UTF8_COUNT_TRAIL_BYTES);
	177	TESTCASE_AUTO(TestSTLCompatibility);
729e4ab9 A	178	TESTCASE_AUTO(TestStringPiece);
	179	TESTCASE_AUTO(TestStringPieceComparisons);
	180	TESTCASE_AUTO(TestByteSink);
	181	TESTCASE_AUTO(TestCheckedArrayByteSink);
	182	TESTCASE_AUTO(TestStringByteSink);
	183	TESTCASE_AUTO(TestCharString);
2ca993e8	184	TESTCASE_AUTO(TestCStr);
f3c0d7a5	185	TESTCASE_AUTO(Testctou);
729e4ab9 A	186	TESTCASE_AUTO_END;
	187	}
	188
729e4ab9 A	189	void
	190	StringTest::TestStringPiece() {
	191	// Default constructor.
	192	StringPiece empty;
	193	if(!empty.empty() \|\| empty.data()!=NULL \|\| empty.length()!=0 \|\| empty.size()!=0) {
	194	errln("StringPiece() failed");
	195	}
	196	// Construct from NULL const char * pointer.
	197	StringPiece null(NULL);
	198	if(!null.empty() \|\| null.data()!=NULL \|\| null.length()!=0 \|\| null.size()!=0) {
	199	errln("StringPiece(NULL) failed");
	200	}
	201	// Construct from const char * pointer.
	202	static const char *abc_chars="abc";
	203	StringPiece abc(abc_chars);
	204	if(abc.empty() \|\| abc.data()!=abc_chars \|\| abc.length()!=3 \|\| abc.size()!=3) {
	205	errln("StringPiece(abc_chars) failed");
	206	}
	207	// Construct from const char * pointer and length.
	208	static const char *abcdefg_chars="abcdefg";
	209	StringPiece abcd(abcdefg_chars, 4);
	210	if(abcd.empty() \|\| abcd.data()!=abcdefg_chars \|\| abcd.length()!=4 \|\| abcd.size()!=4) {
	211	errln("StringPiece(abcdefg_chars, 4) failed");
	212	}
729e4ab9	213	// Construct from std::string.
4388f060	214	std::string uvwxyz_string("uvwxyz");
729e4ab9 A	215	StringPiece uvwxyz(uvwxyz_string);
	216	if(uvwxyz.empty() \|\| uvwxyz.data()!=uvwxyz_string.data() \|\| uvwxyz.length()!=6 \|\| uvwxyz.size()!=6) {
	217	errln("StringPiece(uvwxyz_string) failed");
	218	}
729e4ab9 A	219	// Substring constructor with pos.
	220	StringPiece sp(abcd, -1);
	221	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
	222	errln("StringPiece(abcd, -1) failed");
	223	}
	224	sp=StringPiece(abcd, 5);
	225	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	226	errln("StringPiece(abcd, 5) failed");
	227	}
	228	sp=StringPiece(abcd, 2);
	229	if(sp.empty() \|\| sp.data()!=abcdefg_chars+2 \|\| sp.length()!=2 \|\| sp.size()!=2) {
	230	errln("StringPiece(abcd, -1) failed");
	231	}
	232	// Substring constructor with pos and len.
	233	sp=StringPiece(abcd, -1, 8);
	234	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
	235	errln("StringPiece(abcd, -1, 8) failed");
	236	}
	237	sp=StringPiece(abcd, 5, 8);
	238	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	239	errln("StringPiece(abcd, 5, 8) failed");
	240	}
	241	sp=StringPiece(abcd, 2, 8);
	242	if(sp.empty() \|\| sp.data()!=abcdefg_chars+2 \|\| sp.length()!=2 \|\| sp.size()!=2) {
	243	errln("StringPiece(abcd, -1) failed");
	244	}
	245	sp=StringPiece(abcd, 2, -1);
	246	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	247	errln("StringPiece(abcd, 5, -1) failed");
	248	}
	249	// static const npos
	250	const int32_t *ptr_npos=&StringPiece::npos;
	251	if(StringPiece::npos!=0x7fffffff \|\| *ptr_npos!=0x7fffffff) {
	252	errln("StringPiece::npos!=0x7fffffff");
	253	}
	254	// substr() method with pos, using len=npos.
	255	sp=abcd.substr(-1);
	256	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
	257	errln("abcd.substr(-1) failed");
	258	}
	259	sp=abcd.substr(5);
	260	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	261	errln("abcd.substr(5) failed");
	262	}
	263	sp=abcd.substr(2);
	264	if(sp.empty() \|\| sp.data()!=abcdefg_chars+2 \|\| sp.length()!=2 \|\| sp.size()!=2) {
	265	errln("abcd.substr(-1) failed");
	266	}
	267	// substr() method with pos and len.
	268	sp=abcd.substr(-1, 8);
	269	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
	270	errln("abcd.substr(-1, 8) failed");
	271	}
	272	sp=abcd.substr(5, 8);
	273	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	274	errln("abcd.substr(5, 8) failed");
	275	}
	276	sp=abcd.substr(2, 8);
	277	if(sp.empty() \|\| sp.data()!=abcdefg_chars+2 \|\| sp.length()!=2 \|\| sp.size()!=2) {
	278	errln("abcd.substr(-1) failed");
	279	}
	280	sp=abcd.substr(2, -1);
	281	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
	282	errln("abcd.substr(5, -1) failed");
283	}
284	// clear()
285	sp=abcd;
286	sp.clear();
287	if(!sp.empty() \|\| sp.data()!=NULL \|\| sp.length()!=0 \|\| sp.size()!=0) {
288	errln("abcd.clear() failed");
289	}
290	// remove_prefix()
291	sp=abcd;
292	sp.remove_prefix(-1);
293	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
294	errln("abcd.remove_prefix(-1) failed");
295	}
296	sp=abcd;
297	sp.remove_prefix(2);
298	if(sp.empty() \|\| sp.data()!=abcdefg_chars+2 \|\| sp.length()!=2 \|\| sp.size()!=2) {
299	errln("abcd.remove_prefix(2) failed");
300	}
301	sp=abcd;
302	sp.remove_prefix(5);
303	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
304	errln("abcd.remove_prefix(5) failed");
305	}
306	// remove_suffix()
307	sp=abcd;
308	sp.remove_suffix(-1);
309	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=4 \|\| sp.size()!=4) {
310	errln("abcd.remove_suffix(-1) failed");
311	}
312	sp=abcd;
313	sp.remove_suffix(2);
314	if(sp.empty() \|\| sp.data()!=abcdefg_chars \|\| sp.length()!=2 \|\| sp.size()!=2) {
315	errln("abcd.remove_suffix(2) failed");
316	}
317	sp=abcd;
318	sp.remove_suffix(5);
319	if(!sp.empty() \|\| sp.length()!=0 \|\| sp.size()!=0) {
320	errln("abcd.remove_suffix(5) failed");
321	}
322	}
323
324	void
325	StringTest::TestStringPieceComparisons() {
326	StringPiece empty;
327	StringPiece null(NULL);
328	StringPiece abc("abc");
329	StringPiece abcd("abcdefg", 4);
330	StringPiece abx("abx");
331	if(empty!=null) {
332	errln("empty!=null");
333	}
334	if(empty==abc) {
335	errln("empty==abc");
336	}
337	if(abc==abcd) {
338	errln("abc==abcd");
339	}
340	abcd.remove_suffix(1);
341	if(abc!=abcd) {
342	errln("abc!=abcd.remove_suffix(1)");
343	}
344	if(abc==abx) {
345	errln("abc==abx");
346	}
347	}
348
349	// Verify that ByteSink is subclassable and Flush() overridable.
350	class SimpleByteSink : public ByteSink {
351	public:
352	SimpleByteSink(char *outbuf) : fOutbuf(outbuf), fLength(0) {}
353	virtual void Append(const char *bytes, int32_t n) {
354	if(fOutbuf != bytes) {
355	memcpy(fOutbuf, bytes, n);
b75a7d8f	356	}
729e4ab9 A	357	fOutbuf += n;
	358	fLength += n;
	359	}
	360	virtual void Flush() { Append("z", 1); }
	361	int32_t length() { return fLength; }
	362	private:
	363	char *fOutbuf;
	364	int32_t fLength;
	365	};
	366
	367	// Test the ByteSink base class.
	368	void
	369	StringTest::TestByteSink() {
	370	char buffer[20];
	371	buffer[4] = '!';
	372	SimpleByteSink sink(buffer);
	373	sink.Append("abc", 3);
	374	sink.Flush();
	375	if(!(sink.length() == 4 && 0 == memcmp("abcz", buffer, 4) && buffer[4] == '!')) {
	376	errln("ByteSink (SimpleByteSink) did not Append() or Flush() as expected");
	377	return;
	378	}
	379	char scratch[20];
	380	int32_t capacity = -1;
	381	char *dest = sink.GetAppendBuffer(0, 50, scratch, (int32_t)sizeof(scratch), &capacity);
	382	if(dest != NULL \|\| capacity != 0) {
	383	errln("ByteSink.GetAppendBuffer(min_capacity<1) did not properly return NULL[0]");
	384	return;
	385	}
	386	dest = sink.GetAppendBuffer(10, 50, scratch, 9, &capacity);
	387	if(dest != NULL \|\| capacity != 0) {
	388	errln("ByteSink.GetAppendBuffer(scratch_capacity<min_capacity) did not properly return NULL[0]");
	389	return;
	390	}
	391	dest = sink.GetAppendBuffer(5, 50, scratch, (int32_t)sizeof(scratch), &capacity);
	392	if(dest != scratch \|\| capacity != (int32_t)sizeof(scratch)) {
	393	errln("ByteSink.GetAppendBuffer() did not properly return the scratch buffer");
	394	}
	395	}
	396
	397	void
	398	StringTest::TestCheckedArrayByteSink() {
	399	char buffer[20]; // < 26 for the test code to work
	400	buffer[3] = '!';
	401	CheckedArrayByteSink sink(buffer, (int32_t)sizeof(buffer));
	402	sink.Append("abc", 3);
	403	if(!(sink.NumberOfBytesAppended() == 3 && sink.NumberOfBytesWritten() == 3 &&
	404	0 == memcmp("abc", buffer, 3) && buffer[3] == '!') &&
	405	!sink.Overflowed()
	406	) {
	407	errln("CheckedArrayByteSink did not Append() as expected");
	408	return;
	409	}
	410	char scratch[10];
	411	int32_t capacity = -1;
	412	char *dest = sink.GetAppendBuffer(0, 50, scratch, (int32_t)sizeof(scratch), &capacity);
	413	if(dest != NULL \|\| capacity != 0) {
	414	errln("CheckedArrayByteSink.GetAppendBuffer(min_capacity<1) did not properly return NULL[0]");
	415	return;
	416	}
	417	dest = sink.GetAppendBuffer(10, 50, scratch, 9, &capacity);
	418	if(dest != NULL \|\| capacity != 0) {
	419	errln("CheckedArrayByteSink.GetAppendBuffer(scratch_capacity<min_capacity) did not properly return NULL[0]");
	420	return;
421	}
422	dest = sink.GetAppendBuffer(10, 50, scratch, (int32_t)sizeof(scratch), &capacity);
423	if(dest != buffer + 3 \|\| capacity != (int32_t)sizeof(buffer) - 3) {
424	errln("CheckedArrayByteSink.GetAppendBuffer() did not properly return its own buffer");
425	return;
426	}
427	memcpy(dest, "defghijklm", 10);
428	sink.Append(dest, 10);
429	if(!(sink.NumberOfBytesAppended() == 13 && sink.NumberOfBytesWritten() == 13 &&
430	0 == memcmp("abcdefghijklm", buffer, 13) &&
431	!sink.Overflowed())
432	) {
433	errln("CheckedArrayByteSink did not Append(its own buffer) as expected");
434	return;
435	}
436	dest = sink.GetAppendBuffer(10, 50, scratch, (int32_t)sizeof(scratch), &capacity);
437	if(dest != scratch \|\| capacity != (int32_t)sizeof(scratch)) {
438	errln("CheckedArrayByteSink.GetAppendBuffer() did not properly return the scratch buffer");
439	}
440	memcpy(dest, "nopqrstuvw", 10);
441	sink.Append(dest, 10);
442	if(!(sink.NumberOfBytesAppended() == 23 &&
443	sink.NumberOfBytesWritten() == (int32_t)sizeof(buffer) &&
444	0 == memcmp("abcdefghijklmnopqrstuvwxyz", buffer, (int32_t)sizeof(buffer)) &&
445	sink.Overflowed())
446	) {
447	errln("CheckedArrayByteSink did not Append(scratch buffer) as expected");
448	return;
449	}
450	sink.Reset().Append("123", 3);
451	if(!(sink.NumberOfBytesAppended() == 3 && sink.NumberOfBytesWritten() == 3 &&
452	0 == memcmp("123defghijklmnopqrstuvwxyz", buffer, (int32_t)sizeof(buffer)) &&
453	!sink.Overflowed())
454	) {
455	errln("CheckedArrayByteSink did not Reset().Append() as expected");
456	return;
457	}
458	}
459
460	void
461	StringTest::TestStringByteSink() {
0f5d89e8	462	// Not much to test because only the constructors and Append()
729e4ab9	463	// are implemented, and trivially so.
4388f060 A	464	std::string result("abc"); // std::string
4388f060 A	465	StringByteSink<std::string> sink(&result);
729e4ab9 A	466	sink.Append("def", 3);
	467	if(result != "abcdef") {
	468	errln("StringByteSink did not Append() as expected");
	469	}
0f5d89e8 A	470	StringByteSink<std::string> sink2(&result, 20);
	471	if(result.capacity() < (result.length() + 20)) {
	472	errln("StringByteSink should have 20 append capacity, has only %d",
	473	(int)(result.capacity() - result.length()));
	474	}
	475	sink.Append("ghi", 3);
	476	if(result != "abcdefghi") {
	477	errln("StringByteSink did not Append() as expected");
	478	}
729e4ab9 A	479	}
729e4ab9 A	480
4388f060	481	#if defined(_MSC_VER)
729e4ab9	482	#include <vector>
374ca955	483	#endif
729e4ab9 A	484
	485	void
	486	StringTest::TestSTLCompatibility() {
4388f060	487	#if defined(_MSC_VER)
729e4ab9 A	488	/* Just make sure that it compiles with STL's placement new usage. */
	489	std::vector<UnicodeString> myvect;
	490	myvect.push_back(UnicodeString("blah"));
	491	#endif
	492	}
	493
	494	void
	495	StringTest::TestCharString() {
	496	IcuTestErrorCode errorCode(*this, "TestCharString()");
	497	char expected[400];
	498	static const char longStr[] =
	499	"This is a long string that is meant to cause reallocation of the internal buffer of CharString.";
	500	CharString chStr(longStr, errorCode);
	501	if (0 != strcmp(longStr, chStr.data()) \|\| (int32_t)strlen(longStr) != chStr.length()) {
	502	errln("CharString(longStr) failed.");
	503	}
	504	CharString test("Test", errorCode);
	505	CharString copy(test,errorCode);
	506	copy.copyFrom(chStr, errorCode);
	507	if (0 != strcmp(longStr, copy.data()) \|\| (int32_t)strlen(longStr) != copy.length()) {
	508	errln("CharString.copyFrom() failed.");
	509	}
	510	StringPiece sp(chStr.toStringPiece());
	511	sp.remove_prefix(4);
	512	chStr.append(sp, errorCode).append(chStr, errorCode);
	513	strcpy(expected, longStr);
	514	strcat(expected, longStr+4);
	515	strcat(expected, longStr);
	516	strcat(expected, longStr+4);
	517	if (0 != strcmp(expected, chStr.data()) \|\| (int32_t)strlen(expected) != chStr.length()) {
	518	errln("CharString(longStr).append(substring of self).append(self) failed.");
	519	}
	520	chStr.clear().append("abc", errorCode).append("defghij", 3, errorCode);
	521	if (0 != strcmp("abcdef", chStr.data()) \|\| 6 != chStr.length()) {
	522	errln("CharString.clear().append(abc).append(defghij, 3) failed.");
	523	}
	524	chStr.appendInvariantChars(UNICODE_STRING_SIMPLE(
	525	"This is a long string that is meant to cause reallocation of the internal buffer of CharString."),
	526	errorCode);
	527	strcpy(expected, "abcdef");
	528	strcat(expected, longStr);
	529	if (0 != strcmp(expected, chStr.data()) \|\| (int32_t)strlen(expected) != chStr.length()) {
	530	errln("CharString.appendInvariantChars(longStr) failed.");
	531	}
	532	int32_t appendCapacity = 0;
	533	char *buffer = chStr.getAppendBuffer(5, 10, appendCapacity, errorCode);
	534	if (errorCode.isFailure()) {
	535	return;
	536	}
	537	memcpy(buffer, "*****", 5);
	538	chStr.append(buffer, 5, errorCode);
	539	chStr.truncate(chStr.length()-3);
	540	strcat(expected, "**");
	541	if (0 != strcmp(expected, chStr.data()) \|\| (int32_t)strlen(expected) != chStr.length()) {
	542	errln("CharString.getAppendBuffer().append(**) failed.");
b75a7d8f	543	}
2ca993e8 A	544
	545	UErrorCode ec = U_ZERO_ERROR;
	546	chStr.clear();
	547	chStr.appendInvariantChars(UnicodeString("The '@' character is not invariant."), ec);
	548	if (ec != U_INVARIANT_CONVERSION_ERROR) {
	549	errln("%s:%d expected U_INVARIANT_CONVERSION_ERROR, got %s", __FILE__, __LINE__, u_errorName(ec));
	550	}
	551	if (chStr.length() != 0) {
	552	errln("%s:%d expected length() = 0, got %d", __FILE__, __LINE__, chStr.length());
	553	}
0f5d89e8 A	554
	555	{
	556	CharString s1("Short string", errorCode);
	557	CharString s2(std::move(s1));
	558	assertEquals("s2 should have content of s1", "Short string", s2.data());
	559	CharString s3("Dummy", errorCode);
	560	s3 = std::move(s2);
	561	assertEquals("s3 should have content of s2", "Short string", s3.data());
	562	}
	563
	564	{
	565	CharString s1("Long string over 40 characters to trigger heap allocation", errorCode);
	566	CharString s2(std::move(s1));
	567	assertEquals("s2 should have content of s1",
	568	"Long string over 40 characters to trigger heap allocation",
	569	s2.data());
	570	CharString s3("Dummy string with over 40 characters to trigger heap allocation", errorCode);
	571	s3 = std::move(s2);
	572	assertEquals("s3 should have content of s2",
	573	"Long string over 40 characters to trigger heap allocation",
	574	s3.data());
	575	}
2ca993e8 A	576	}
	577
	578	void
	579	StringTest::TestCStr() {
	580	const char *cs = "This is a test string.";
	581	UnicodeString us(cs);
	582	if (0 != strcmp(CStr(us)(), cs)) {
	583	errln("%s:%d CStr(s)() failed. Expected \"%s\", got \"%s\"", __FILE__, __LINE__, cs, CStr(us)());
	584	}
b75a7d8f	585	}
f3c0d7a5 A	586
	587	void
	588	StringTest::Testctou() {
	589	const char *cs = "Fa\\u0127mu";
	590	UnicodeString u = ctou(cs);
	591	assertEquals("Testing unescape@0", (int32_t)0x0046, u.charAt(0));
	592	assertEquals("Testing unescape@2", (int32_t)295, u.charAt(2));
	593	}