+UnicodeString CharsToUnicodeString(const char* chars){
+ return UnicodeString(chars, -1, US_INV).unescape();
+}
+
+UnicodeString ctou(const char* chars) {
+ return CharsToUnicodeString(chars);
+}
+
+#define RAND_M (714025)
+#define RAND_IA (1366)
+#define RAND_IC (150889)
+
+static int32_t RAND_SEED;
+
+/**
+ * Returns a uniform random value x, with 0.0 <= x < 1.0. Use
+ * with care: Does not return all possible values; returns one of
+ * 714,025 values, uniformly spaced. However, the period is
+ * effectively infinite. See: Numerical Recipes, section 7.1.
+ *
+ * @param seedp pointer to seed. Set *seedp to any negative value
+ * to restart the sequence.
+ */
+float IntlTest::random(int32_t* seedp) {
+ static int32_t iy, ir[98];
+ static UBool first=TRUE;
+ int32_t j;
+ if (*seedp < 0 || first) {
+ first = FALSE;
+ if ((*seedp=(RAND_IC-(*seedp)) % RAND_M) < 0) *seedp = -(*seedp);
+ for (j=1;j<=97;++j) {
+ *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M;
+ ir[j]=(*seedp);
+ }
+ *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M;
+ iy=(*seedp);
+ }
+ j=(int32_t)(1 + 97.0*iy/RAND_M);
+ U_ASSERT(j>=1 && j<=97);
+ iy=ir[j];
+ *seedp=(RAND_IA*(*seedp)+RAND_IC) % RAND_M;
+ ir[j]=(*seedp);
+ return (float) iy/RAND_M;
+}
+
+/**
+ * Convenience method using a global seed.
+ */
+float IntlTest::random() {
+ return random(&RAND_SEED);
+}
+
+static inline UChar toHex(int32_t i) {
+ return (UChar)(i + (i < 10 ? 0x30 : (0x41 - 10)));
+}
+
+static UnicodeString& escape(const UnicodeString& s, UnicodeString& result) {
+ for (int32_t i=0; i<s.length(); ++i) {
+ UChar c = s[i];
+ if (c <= (UChar)0x7F) {
+ result += c;
+ } else {
+ result += (UChar)0x5c;
+ result += (UChar)0x75;
+ result += toHex((c >> 12) & 0xF);
+ result += toHex((c >> 8) & 0xF);
+ result += toHex((c >> 4) & 0xF);
+ result += toHex( c & 0xF);
+ }
+ }
+ return result;
+}
+
+#define VERBOSE_ASSERTIONS
+
+UBool IntlTest::assertTrue(const char* message, UBool condition, UBool quiet, UBool possibleDataError, const char *file, int line) {
+ if (file != NULL) {
+ if (!condition) {
+ if (possibleDataError) {
+ dataerrln("%s:%d: FAIL: assertTrue() failed: %s", file, line, message);
+ } else {
+ errln("%s:%d: FAIL: assertTrue() failed: %s", file, line, message);
+ }
+ } else if (!quiet) {
+ logln("%s:%d: Ok: %s", file, line, message);
+ }
+ } else {
+ if (!condition) {
+ if (possibleDataError) {
+ dataerrln("FAIL: assertTrue() failed: %s", message);
+ } else {
+ errln("FAIL: assertTrue() failed: %s", message);
+ }
+ } else if (!quiet) {
+ logln("Ok: %s", message);
+ }
+
+ }
+ return condition;
+}
+
+UBool IntlTest::assertFalse(const char* message, UBool condition, UBool quiet) {
+ if (condition) {
+ errln("FAIL: assertFalse() failed: %s", message);
+ } else if (!quiet) {
+ logln("Ok: %s", message);
+ }
+ return !condition;
+}
+
+UBool IntlTest::assertSuccess(const char* message, UErrorCode ec, UBool possibleDataError) {
+ if (U_FAILURE(ec)) {
+ if (possibleDataError) {
+ dataerrln("FAIL: %s (%s)", message, u_errorName(ec));
+ } else {
+ errcheckln(ec, "FAIL: %s (%s)", message, u_errorName(ec));
+ }
+
+ return FALSE;
+ }
+ return TRUE;
+}
+
+UBool IntlTest::assertEquals(const char* message,
+ const UnicodeString& expected,
+ const UnicodeString& actual,
+ UBool possibleDataError) {
+ if (expected != actual) {
+ if (possibleDataError) {
+ dataerrln((UnicodeString)"FAIL: " + message + "; got " +
+ prettify(actual) +
+ "; expected " + prettify(expected));
+ } else {
+ errln((UnicodeString)"FAIL: " + message + "; got " +
+ prettify(actual) +
+ "; expected " + prettify(expected));
+ }
+ return FALSE;
+ }
+#ifdef VERBOSE_ASSERTIONS
+ else {
+ logln((UnicodeString)"Ok: " + message + "; got " + prettify(actual));
+ }
+#endif
+ return TRUE;
+}
+
+UBool IntlTest::assertEquals(const char* message,
+ const char* expected,
+ const char* actual) {
+ if (uprv_strcmp(expected, actual) != 0) {
+ errln((UnicodeString)"FAIL: " + message + "; got \"" +
+ actual +
+ "\"; expected \"" + expected + "\"");
+ return FALSE;
+ }
+#ifdef VERBOSE_ASSERTIONS
+ else {
+ logln((UnicodeString)"Ok: " + message + "; got \"" + actual + "\"");
+ }
+#endif
+ return TRUE;
+}
+
+UBool IntlTest::assertEquals(const char* message,
+ int32_t expected,
+ int32_t actual) {
+ if (expected != actual) {
+ errln((UnicodeString)"FAIL: " + message + "; got " +
+ actual + "=0x" + toHex(actual) +
+ "; expected " + expected + "=0x" + toHex(expected));
+ return FALSE;
+ }
+#ifdef VERBOSE_ASSERTIONS
+ else {
+ logln((UnicodeString)"Ok: " + message + "; got " + actual + "=0x" + toHex(actual));
+ }
+#endif
+ return TRUE;
+}
+
+#if !UCONFIG_NO_FORMATTING
+UBool IntlTest::assertEquals(const char* message,
+ const Formattable& expected,
+ const Formattable& actual) {
+ if (expected != actual) {
+ errln((UnicodeString)"FAIL: " + message + "; got " +
+ toString(actual) +
+ "; expected " + toString(expected));
+ return FALSE;
+ }
+#ifdef VERBOSE_ASSERTIONS
+ else {
+ logln((UnicodeString)"Ok: " + message + "; got " + toString(actual));
+ }
+#endif
+ return TRUE;
+}
+#endif
+
+static char ASSERT_BUF[256];
+
+static const char* extractToAssertBuf(const UnicodeString& message) {
+ UnicodeString buf;
+ escape(message, buf);
+ buf.extract(0, 0x7FFFFFFF, ASSERT_BUF, sizeof(ASSERT_BUF)-1, 0);
+ ASSERT_BUF[sizeof(ASSERT_BUF)-1] = 0;
+ return ASSERT_BUF;
+}
+
+UBool IntlTest::assertTrue(const UnicodeString& message, UBool condition, UBool quiet) {
+ return assertTrue(extractToAssertBuf(message), condition, quiet);
+}
+
+UBool IntlTest::assertFalse(const UnicodeString& message, UBool condition, UBool quiet) {
+ return assertFalse(extractToAssertBuf(message), condition, quiet);
+}
+
+UBool IntlTest::assertSuccess(const UnicodeString& message, UErrorCode ec) {
+ return assertSuccess(extractToAssertBuf(message), ec);
+}
+
+UBool IntlTest::assertEquals(const UnicodeString& message,
+ const UnicodeString& expected,
+ const UnicodeString& actual) {
+ return assertEquals(extractToAssertBuf(message), expected, actual);
+}
+
+UBool IntlTest::assertEquals(const UnicodeString& message,
+ const char* expected,
+ const char* actual) {
+ return assertEquals(extractToAssertBuf(message), expected, actual);
+}
+//--------------------------------------------------------------------
+// Time bomb - allows temporary behavior that expires at a given
+// release
+//--------------------------------------------------------------------
+
+UBool IntlTest::isICUVersionBefore(int major, int minor, int milli) {
+ UVersionInfo iv;
+ UVersionInfo ov = { (uint8_t)major, (uint8_t)minor, (uint8_t)milli, 0 };
+ u_getVersion(iv);
+ return uprv_memcmp(iv, ov, U_MAX_VERSION_LENGTH) < 0;
+}
+
+#if !UCONFIG_NO_FORMATTING
+UBool IntlTest::assertEquals(const UnicodeString& message,
+ const Formattable& expected,
+ const Formattable& actual) {
+ return assertEquals(extractToAssertBuf(message), expected, actual);
+}
+#endif
+
+void IntlTest::setProperty(const char* propline) {
+ if (numProps < kMaxProps) {
+ proplines[numProps] = propline;
+ }
+ numProps++;
+}
+
+const char* IntlTest::getProperty(const char* prop) {
+ const char* val = NULL;
+ for (int32_t i = 0; i < numProps; i++) {
+ int32_t plen = uprv_strlen(prop);
+ if ((int32_t)uprv_strlen(proplines[i]) > plen + 1
+ && proplines[i][plen] == '='
+ && uprv_strncmp(proplines[i], prop, plen) == 0) {
+ val = &(proplines[i][plen+1]);
+ break;
+ }
+ }
+ return val;
projects / apple / icu.git / blobdiff