X-Git-Url: https://git.saurik.com/apple/icu.git/blobdiff_plain/374ca955a76ecab1204ca8bfa63ff9238d998416..e4f10fab0c078f399c9deef476d9c9b73b47dff8:/icuSources/test/intltest/strtest.cpp

diff --git a/icuSources/test/intltest/strtest.cpp b/icuSources/test/intltest/strtest.cpp
index 4ba90832..2081454d 100644
--- a/icuSources/test/intltest/strtest.cpp
+++ b/icuSources/test/intltest/strtest.cpp
@@ -1,6 +1,6 @@
 /********************************************************************
  * COPYRIGHT: 
- * Copyright (c) 1997-2004, International Business Machines Corporation and
+ * Copyright (c) 1997-2012, International Business Machines Corporation and
  * others. All Rights Reserved.
  ********************************************************************/
 /*   file name:  strtest.cpp
@@ -12,16 +12,17 @@
 *   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 "charstr.h"
 #include "intltest.h"
 #include "strtest.h"
-#include "unicode/ustring.h"
-
-#if defined(WIN32) && defined(_MSC_VER)
-#include <vector>
-using namespace std;
-#endif
 
 StringTest::~StringTest() {}
 
@@ -81,8 +82,8 @@ void StringTest::TestSizeofTypes(void) {
 
 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
+    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");
     }
@@ -90,103 +91,434 @@ void StringTest::TestCharsetFamily(void) {
 
 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(UTF8_COUNT_TRAIL_BYTES(0x7F) != 0
+        || UTF8_COUNT_TRAIL_BYTES(0xC0) != 1
+        || UTF8_COUNT_TRAIL_BYTES(0xE0) != 2
+        || UTF8_COUNT_TRAIL_BYTES(0xF0) != 3)
+    {
+        errln("Test_UTF8_COUNT_TRAIL_BYTES: UTF8_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: ");
     }
-    switch(index) {
-    case 0:
-        name="TestEndian";
-        if(exec) {
-            TestEndian();
-        }
-        break;
-    case 1:
-        name="TestSizeofTypes";
-        if(exec) {
-            TestSizeofTypes();
-        }
-        break;
-    case 2:
-        name="TestCharsetFamily";
-        if(exec) {
-            TestCharsetFamily();
-        }
-        break;
-    case 3:
-        name="Test_U_STRING";
-        if(exec) {
-            U_STRING_INIT(ustringVar, "aZ0 -", 5);
-            if( sizeof(ustringVar)/sizeof(*ustringVar)!=6 ||
-                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.");
-            }
-        }
-        break;
-    case 4:
-        name="Test_UNICODE_STRING";
-        if(exec) {
-            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.");
-            }
-        }
-        break;
-    case 5:
-        name="Test_UNICODE_STRING_SIMPLE";
-        if(exec) {
-            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.");
-            }
-        }
-        break;
-    case 6:
-        name="Test_UTF8_COUNT_TRAIL_BYTES";
-        if(exec) {
-            if(UTF8_COUNT_TRAIL_BYTES(0x7F) != 0
-                || UTF8_COUNT_TRAIL_BYTES(0xC0) != 1
-                || UTF8_COUNT_TRAIL_BYTES(0xE0) != 2
-                || UTF8_COUNT_TRAIL_BYTES(0xF0) != 3)
-            {
-                errln("Test_UTF8_COUNT_TRAIL_BYTES: UTF8_COUNT_TRAIL_BYTES does not work right! "
-                      "See utf8.h.");
-            }
-        }
-        break;
-    case 7:
-        name="TestSTLCompatibility";
-        if(exec) {
-#if defined(WIN32) && defined(_MSC_VER)
-            /* Just make sure that it compiles with STL's placement new usage. */
-            vector<UnicodeString> myvect;
-            myvect.push_back(UnicodeString("blah"));
+    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_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");
+    }
+#if U_HAVE_STD_STRING
+    // 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");
+    }
 #endif
+    // 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);
         }
-        break;
-    default:
-        name="";
-        break;
+        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() {
+#if U_HAVE_STD_STRING
+    // Not much to test because only the constructor 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");
+    }
+#endif
+}
+
+#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.");
     }
 }