diff --git a/icu4c/source/i18n/number_formatimpl.cpp b/icu4c/source/i18n/number_formatimpl.cpp
index d9e1cbd..3f88712 100644
--- a/icu4c/source/i18n/number_formatimpl.cpp
+++ b/icu4c/source/i18n/number_formatimpl.cpp
@@ -93,6 +93,7 @@
                                 UErrorCode& status) const {
     if (U_FAILURE(status)) { return; }
     MicroProps micros;
+    if (!fMicroPropsGenerator) { return; }
     fMicroPropsGenerator->processQuantity(inValue, micros, status);
     if (U_FAILURE(status)) { return; }
     microsToString(micros, inValue, outString, status);
diff --git a/icu4c/source/test/cintltst/cmsgtst.c b/icu4c/source/test/cintltst/cmsgtst.c
index 93ef88f..34b0566 100644
--- a/icu4c/source/test/cintltst/cmsgtst.c
+++ b/icu4c/source/test/cintltst/cmsgtst.c
@@ -375,13 +375,13 @@
 static void TestNewFormatAndParseAPI(void)
 {
 
-    UChar *result, tzID[4], str[25];
+    UChar *result = NULL, tzID[4], str[25];
     UChar pattern[100];
     UChar expected[100];
     int32_t resultLengthOut, resultlength;
     UCalendar *cal;
     UDate d1,d;
-    UDateFormat *def1;
+    UDateFormat *def1 = NULL;
     UErrorCode status = U_ZERO_ERROR;
     int32_t value = 0;
     UChar ret[30];
@@ -398,13 +398,12 @@
     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
     if(U_FAILURE(status)){
         log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) );
-        return;
+        goto cleanup;
     }
     ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status);
     d1=ucal_getMillis(cal, &status);
     if(U_FAILURE(status)){
-            log_err("Error: failure in get millis: %s\n", myErrorName(status) );
-            return;
+        log_err("Error: failure in get millis: %s\n", myErrorName(status) );
     }
     
     log_verbose("\nTesting with pattern test#4");
@@ -414,7 +413,7 @@
     fmt = umsg_open(pattern,u_strlen(pattern),"en_US",&parseError,&status);
     if(U_FAILURE(status)){
         log_data_err("error in umsg_open  : %s (Are you missing data?)\n", u_errorName(status) );
-        return;
+        goto cleanup;
     }
     result=(UChar*)malloc(sizeof(UChar) * resultlength);
     
@@ -463,6 +462,7 @@
                 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) );
         }
     }
+cleanup:
     umsg_close(fmt);
     udat_close(def1);
     ucal_close(cal);
@@ -483,7 +483,7 @@
     int32_t resultLengthOut, resultlength;
     UCalendar *cal;
     UDate d1,d;
-    UDateFormat *def1;
+    UDateFormat *def1 = NULL;
     UErrorCode status = U_ZERO_ERROR;
     int32_t value = 0;
     UChar ret[30];
@@ -523,6 +523,7 @@
     }
     if(U_FAILURE(status)){
         log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status));
+        goto cleanup;
     }
     else if(u_strcmp(result, expected)==0)
         log_verbose("PASS: MessagFormat successful on test#4\n");
@@ -557,6 +558,7 @@
                 austrdup(myDateFormat(def1,d)), austrdup(myDateFormat(def1,d1)) );
         }
     }
+cleanup:
     udat_close(def1);
     ucal_close(cal);
 
@@ -593,11 +595,12 @@
     cal=ucal_open(tzID, u_strlen(tzID), "en_US", UCAL_TRADITIONAL, &status);
     if(U_FAILURE(status)){
         log_data_err("error in ucal_open caldef : %s - (Are you missing data?)\n", myErrorName(status) );
+        return;
     }
     ucal_setDateTime(cal, 1999, UCAL_MARCH, 18, 0, 0, 0, &status);
     d1=ucal_getMillis(cal, &status);
     if(U_FAILURE(status)){
-            log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) );
+        log_data_err("Error: failure in get millis: %s - (Are you missing data?)\n", myErrorName(status) );
     }
     
     log_verbose("\nTesting with pattern test#4");
@@ -616,6 +619,7 @@
     }
     if(U_FAILURE(status)){
         log_data_err("ERROR: failure in message format test#4: %s (Are you missing data?)\n", myErrorName(status));
+        return;
     }
     else if(u_strcmp(result, expected)==0)
         log_verbose("PASS: MessagFormat successful on test#4\n");
diff --git a/icu4c/source/test/cintltst/cnormtst.c b/icu4c/source/test/cintltst/cnormtst.c
index 18412f7..fe7237a 100644
--- a/icu4c/source/test/cintltst/cnormtst.c
+++ b/icu4c/source/test/cintltst/cnormtst.c
@@ -1409,6 +1409,10 @@
         }
 
         length=unorm_normalize(s, length, UNORM_NFD, 0, nfd, UPRV_LENGTHOF(nfd), &errorCode);
+        if (U_FAILURE(errorCode)) {
+            log_data_err("%s:%d errorCode=%s\n", __FILE__, __LINE__, u_errorName(errorCode));
+            break;
+        }
         /* length-length == 0 is used to get around a compiler warning. */
         U16_GET(nfd, 0, length-length, length, lead);
         U16_GET(nfd, 0, length-1, length, trail);
diff --git a/icu4c/source/test/cintltst/cnumtst.c b/icu4c/source/test/cintltst/cnumtst.c
index 7559801..7090f67 100644
--- a/icu4c/source/test/cintltst/cnumtst.c
+++ b/icu4c/source/test/cintltst/cnumtst.c
@@ -3070,6 +3070,7 @@
     static const UChar input[] = u"199a";
     UChar currency[200] = {0};
     UNumberFormat *theFormatter = unum_open(UNUM_CURRENCY, NULL, 0, "en_US", NULL, &status);
+    if (!assertSuccessCheck("unum_open() failed", &status, TRUE)) { return; }
     status = U_ZERO_ERROR;
     unum_setAttribute(theFormatter, UNUM_LENIENT_PARSE, 1);
     int32_t pos = 1;
diff --git a/icu4c/source/test/cintltst/unumberformattertst.c b/icu4c/source/test/cintltst/unumberformattertst.c
index 7fe4c11..0d3f7f1 100644
--- a/icu4c/source/test/cintltst/unumberformattertst.c
+++ b/icu4c/source/test/cintltst/unumberformattertst.c
@@ -35,34 +35,37 @@
 static void TestSkeletonFormatToString() {
     UErrorCode ec = U_ZERO_ERROR;
     UChar buffer[CAPACITY];
+    UFormattedNumber* result = NULL;
 
     // setup:
     UNumberFormatter* f = unumf_openForSkeletonAndLocale(
-            u"precision-integer currency/USD sign-accounting", -1, "en", &ec);
-    assertSuccess("Should create without error", &ec);
-    UFormattedNumber* result = unumf_openResult(&ec);
+                              u"precision-integer currency/USD sign-accounting", -1, "en", &ec);
+    assertSuccessCheck("Should create without error", &ec, TRUE);
+    result = unumf_openResult(&ec);
     assertSuccess("Should create result without error", &ec);
 
     // int64 test:
     unumf_formatInt(f, -444444, result, &ec);
-    assertSuccess("Should format integer without error", &ec);
-    unumf_resultToString(result, buffer, CAPACITY, &ec);
-    assertSuccess("Should print string to buffer without error", &ec);
-    assertUEquals("Should produce expected string result", u"($444,444)", buffer);
+    // Missing data will give a U_MISSING_RESOURCE_ERROR here.
+    if (assertSuccessCheck("Should format integer without error", &ec, TRUE)) {
+        unumf_resultToString(result, buffer, CAPACITY, &ec);
+        assertSuccess("Should print string to buffer without error", &ec);
+        assertUEquals("Should produce expected string result", u"($444,444)", buffer);
 
-    // double test:
-    unumf_formatDouble(f, -5142.3, result, &ec);
-    assertSuccess("Should format double without error", &ec);
-    unumf_resultToString(result, buffer, CAPACITY, &ec);
-    assertSuccess("Should print string to buffer without error", &ec);
-    assertUEquals("Should produce expected string result", u"($5,142)", buffer);
+        // double test:
+        unumf_formatDouble(f, -5142.3, result, &ec);
+        assertSuccess("Should format double without error", &ec);
+        unumf_resultToString(result, buffer, CAPACITY, &ec);
+        assertSuccess("Should print string to buffer without error", &ec);
+        assertUEquals("Should produce expected string result", u"($5,142)", buffer);
 
-    // decnumber test:
-    unumf_formatDecimal(f, "9.876E2", -1, result, &ec);
-    assertSuccess("Should format decimal without error", &ec);
-    unumf_resultToString(result, buffer, CAPACITY, &ec);
-    assertSuccess("Should print string to buffer without error", &ec);
-    assertUEquals("Should produce expected string result", u"$988", buffer);
+        // decnumber test:
+        unumf_formatDecimal(f, "9.876E2", -1, result, &ec);
+        assertSuccess("Should format decimal without error", &ec);
+        unumf_resultToString(result, buffer, CAPACITY, &ec);
+        assertSuccess("Should print string to buffer without error", &ec);
+        assertUEquals("Should produce expected string result", u"$988", buffer);
+    }
 
     // cleanup:
     unumf_closeResult(result);
@@ -72,74 +75,79 @@
 
 static void TestSkeletonFormatToFields() {
     UErrorCode ec = U_ZERO_ERROR;
+    UFieldPositionIterator* ufpositer = NULL;
 
     // setup:
     UNumberFormatter* uformatter = unumf_openForSkeletonAndLocale(
             u".00 measure-unit/length-meter sign-always", -1, "en", &ec);
     assertSuccessCheck("Should create without error", &ec, TRUE);
-    if (U_FAILURE(ec)) { return; }
     UFormattedNumber* uresult = unumf_openResult(&ec);
     assertSuccess("Should create result without error", &ec);
     unumf_formatInt(uformatter, 9876543210L, uresult, &ec); // "+9,876,543,210.00 m"
+    if (assertSuccessCheck("unumf_formatInt() failed", &ec, TRUE)) {
 
-    // field position test:
-    UFieldPosition ufpos = {UNUM_DECIMAL_SEPARATOR_FIELD};
-    unumf_resultNextFieldPosition(uresult, &ufpos, &ec);
-    assertIntEquals("Field position should be correct", 14, ufpos.beginIndex);
-    assertIntEquals("Field position should be correct", 15, ufpos.endIndex);
+        // field position test:
+        UFieldPosition ufpos = {UNUM_DECIMAL_SEPARATOR_FIELD};
+        unumf_resultNextFieldPosition(uresult, &ufpos, &ec);
+        assertIntEquals("Field position should be correct", 14, ufpos.beginIndex);
+        assertIntEquals("Field position should be correct", 15, ufpos.endIndex);
 
-    // field position iterator test:
-    UFieldPositionIterator* ufpositer = ufieldpositer_open(&ec);
-    assertSuccess("Should create iterator without error", &ec);
-    unumf_resultGetAllFieldPositions(uresult, ufpositer, &ec);
-    static const UFieldPosition expectedFields[] = {
-            // Field, begin index, end index
-            {UNUM_SIGN_FIELD, 0, 1},
-            {UNUM_GROUPING_SEPARATOR_FIELD, 2, 3},
-            {UNUM_GROUPING_SEPARATOR_FIELD, 6, 7},
-            {UNUM_GROUPING_SEPARATOR_FIELD, 10, 11},
-            {UNUM_INTEGER_FIELD, 1, 14},
-            {UNUM_DECIMAL_SEPARATOR_FIELD, 14, 15},
-            {UNUM_FRACTION_FIELD, 15, 17}};
-    UFieldPosition actual;
-    for (int32_t i = 0; i < sizeof(expectedFields) / sizeof(*expectedFields); i++) {
-        // Iterate using the UFieldPosition to hold state...
-        UFieldPosition expected = expectedFields[i];
-        actual.field = ufieldpositer_next(ufpositer, &actual.beginIndex, &actual.endIndex);
-        assertTrue("Should not return a negative index yet", actual.field >= 0);
-        if (expected.field != actual.field) {
-            log_err(
-                    "FAIL: iteration %d; expected field %d; got %d\n", i, expected.field, actual.field);
-        }
-        if (expected.beginIndex != actual.beginIndex) {
-            log_err(
-                    "FAIL: iteration %d; expected beginIndex %d; got %d\n",
-                    i,
-                    expected.beginIndex,
-                    actual.beginIndex);
-        }
-        if (expected.endIndex != actual.endIndex) {
-            log_err(
-                    "FAIL: iteration %d; expected endIndex %d; got %d\n",
-                    i,
-                    expected.endIndex,
-                    actual.endIndex);
+        // field position iterator test:
+        ufpositer = ufieldpositer_open(&ec);
+        if (assertSuccessCheck("Should create iterator without error", &ec, TRUE)) {
+
+            unumf_resultGetAllFieldPositions(uresult, ufpositer, &ec);
+            static const UFieldPosition expectedFields[] = {
+                // Field, begin index, end index
+                {UNUM_SIGN_FIELD, 0, 1},
+                {UNUM_GROUPING_SEPARATOR_FIELD, 2, 3},
+                {UNUM_GROUPING_SEPARATOR_FIELD, 6, 7},
+                {UNUM_GROUPING_SEPARATOR_FIELD, 10, 11},
+                {UNUM_INTEGER_FIELD, 1, 14},
+                {UNUM_DECIMAL_SEPARATOR_FIELD, 14, 15},
+                {UNUM_FRACTION_FIELD, 15, 17}
+            };
+            UFieldPosition actual;
+            for (int32_t i = 0; i < sizeof(expectedFields) / sizeof(*expectedFields); i++) {
+                // Iterate using the UFieldPosition to hold state...
+                UFieldPosition expected = expectedFields[i];
+                actual.field = ufieldpositer_next(ufpositer, &actual.beginIndex, &actual.endIndex);
+                assertTrue("Should not return a negative index yet", actual.field >= 0);
+                if (expected.field != actual.field) {
+                    log_err(
+                        "FAIL: iteration %d; expected field %d; got %d\n", i, expected.field, actual.field);
+                }
+                if (expected.beginIndex != actual.beginIndex) {
+                    log_err(
+                        "FAIL: iteration %d; expected beginIndex %d; got %d\n",
+                        i,
+                        expected.beginIndex,
+                        actual.beginIndex);
+                }
+                if (expected.endIndex != actual.endIndex) {
+                    log_err(
+                        "FAIL: iteration %d; expected endIndex %d; got %d\n",
+                        i,
+                        expected.endIndex,
+                        actual.endIndex);
+                }
+            }
+            actual.field = ufieldpositer_next(ufpositer, &actual.beginIndex, &actual.endIndex);
+            assertTrue("No more fields; should return a negative index", actual.field < 0);
+
+            // next field iteration:
+            actual.field = UNUM_GROUPING_SEPARATOR_FIELD;
+            actual.beginIndex = 0;
+            actual.endIndex = 0;
+            int32_t i = 1;
+            while (unumf_resultNextFieldPosition(uresult, &actual, &ec)) {
+                UFieldPosition expected = expectedFields[i++];
+                assertIntEquals("Grouping separator begin index", expected.beginIndex, actual.beginIndex);
+                assertIntEquals("Grouping separator end index", expected.endIndex, actual.endIndex);
+            }
+            assertIntEquals("Should have seen all grouping separators", 4, i);
         }
     }
-    actual.field = ufieldpositer_next(ufpositer, &actual.beginIndex, &actual.endIndex);
-    assertTrue("No more fields; should return a negative index", actual.field < 0);
-
-    // next field iteration:
-    actual.field = UNUM_GROUPING_SEPARATOR_FIELD;
-    actual.beginIndex = 0;
-    actual.endIndex = 0;
-    int32_t i = 1;
-    while (unumf_resultNextFieldPosition(uresult, &actual, &ec)) {
-        UFieldPosition expected = expectedFields[i++];
-        assertIntEquals("Grouping separator begin index", expected.beginIndex, actual.beginIndex);
-        assertIntEquals("Grouping separator end index", expected.endIndex, actual.endIndex);
-    }
-    assertIntEquals("Should have seen all grouping separators", 4, i);
 
     // cleanup:
     unumf_closeResult(uresult);
@@ -155,21 +163,22 @@
     UErrorCode ec = U_ZERO_ERROR;
     UNumberFormatter* uformatter = unumf_openForSkeletonAndLocale(u"precision-integer", -1, "en", &ec);
     UFormattedNumber* uresult = unumf_openResult(&ec);
+    UChar* buffer = NULL;
     assertSuccessCheck("There should not be a failure in the example code", &ec, TRUE);
-    if (U_FAILURE(ec)) { return; }
 
     // Format a double:
     unumf_formatDouble(uformatter, 5142.3, uresult, &ec);
-    assertSuccess("There should not be a failure in the example code", &ec);
+    if (assertSuccessCheck("There should not be a failure in the example code", &ec, TRUE)) {
 
-    // Export the string to a malloc'd buffer:
-    int32_t len = unumf_resultToString(uresult, NULL, 0, &ec);
-    assertTrue("No buffer yet", ec == U_BUFFER_OVERFLOW_ERROR);
-    ec = U_ZERO_ERROR;
-    UChar* buffer = (UChar*) uprv_malloc((len+1)*sizeof(UChar));
-    unumf_resultToString(uresult, buffer, len+1, &ec);
-    assertSuccess("There should not be a failure in the example code", &ec);
-    assertUEquals("Should produce expected string result", u"5,142", buffer);
+        // Export the string to a malloc'd buffer:
+        int32_t len = unumf_resultToString(uresult, NULL, 0, &ec);
+        assertTrue("No buffer yet", ec == U_BUFFER_OVERFLOW_ERROR);
+        ec = U_ZERO_ERROR;
+        buffer = (UChar*) uprv_malloc((len+1)*sizeof(UChar));
+        unumf_resultToString(uresult, buffer, len+1, &ec);
+        assertSuccess("There should not be a failure in the example code", &ec);
+        assertUEquals("Should produce expected string result", u"5,142", buffer);
+    }
 
     // Cleanup:
     unumf_close(uformatter);
diff --git a/icu4c/source/test/intltest/compactdecimalformattest.cpp b/icu4c/source/test/intltest/compactdecimalformattest.cpp
index ae114fd0..2ee46ab 100644
--- a/icu4c/source/test/intltest/compactdecimalformattest.cpp
+++ b/icu4c/source/test/intltest/compactdecimalformattest.cpp
@@ -485,17 +485,18 @@
 	IcuTestErrorCode status(*this, "TestBug12975");
     Locale locale("it");
     LocalPointer<CompactDecimalFormat> cdf(CompactDecimalFormat::createInstance(locale, UNUM_SHORT, status));
-    UnicodeString resultCdf;
-    cdf->format(120000, resultCdf);
-    LocalPointer<DecimalFormat> df((DecimalFormat*) DecimalFormat::createInstance(locale, status));
-    UnicodeString resultDefault;
-    df->format(120000, resultDefault);
-    assertEquals("CompactDecimalFormat should use default pattern when compact pattern is unavailable",
-                 resultDefault, resultCdf);
+    if (assertSuccess("", status, true, __FILE__, __LINE__)) {
+        UnicodeString resultCdf;
+        cdf->format(120000, resultCdf);
+        LocalPointer<DecimalFormat> df((DecimalFormat*) DecimalFormat::createInstance(locale, status));
+        UnicodeString resultDefault;
+        df->format(120000, resultDefault);
+        assertEquals("CompactDecimalFormat should use default pattern when compact pattern is unavailable",
+                     resultDefault, resultCdf);
+    }
 }
 
 
-
 // End test cases. Helpers:
 
 void CompactDecimalFormatTest::CheckLocale(const Locale& locale, UNumberCompactStyle style, const ExpectedResult* expectedResults, int32_t expectedResultLength) {
diff --git a/icu4c/source/test/intltest/dtfmttst.cpp b/icu4c/source/test/intltest/dtfmttst.cpp
index 3b14751..b272320 100644
--- a/icu4c/source/test/intltest/dtfmttst.cpp
+++ b/icu4c/source/test/intltest/dtfmttst.cpp
@@ -5543,6 +5543,10 @@
 void DateFormatTest::TestParseRegression13744() {
     LocalPointer<DateFormat> dfmt(DateFormat::createDateTimeInstance(
             DateFormat::SHORT, DateFormat::SHORT, Locale("en", "US")));
+    if (dfmt.isNull()) {
+        dataerrln("DateFormat::createDateTimeInstance() failed");
+        return;
+    }
     ParsePosition pos(0);
     UnicodeString inDate("4/27/18");
     dfmt->parse(inDate, pos);
diff --git a/icu4c/source/test/intltest/itrbnf.cpp b/icu4c/source/test/intltest/itrbnf.cpp
index c62715b..549f24c 100644
--- a/icu4c/source/test/intltest/itrbnf.cpp
+++ b/icu4c/source/test/intltest/itrbnf.cpp
@@ -2291,12 +2291,14 @@
     static const UChar* testData[] = {
         u"・・・・・・・・・・・・・・・・・・・・・・・・"
     };
-    for (int i = 0; i < UPRV_LENGTHOF(testData); ++i) {
-        UnicodeString spelledNumberString(testData[i]);
-        Formattable actualNumber;
-        rbnf.parse(spelledNumberString, actualNumber, status);
-        if (status != U_INVALID_FORMAT_ERROR) { // I would have expected U_PARSE_ERROR, but NumberFormat::parse gives U_INVALID_FORMAT_ERROR
-            errln("FAIL: string should be unparseable index=%d %s", i, u_errorName(status));
+    if (assertSuccess("", status, true, __FILE__, __LINE__)) {
+        for (int i = 0; i < UPRV_LENGTHOF(testData); ++i) {
+            UnicodeString spelledNumberString(testData[i]);
+            Formattable actualNumber;
+            rbnf.parse(spelledNumberString, actualNumber, status);
+            if (status != U_INVALID_FORMAT_ERROR) { // I would have expected U_PARSE_ERROR, but NumberFormat::parse gives U_INVALID_FORMAT_ERROR
+                errln("FAIL: string should be unparseable index=%d %s", i, u_errorName(status));
+            }
         }
     }
 }
@@ -2307,13 +2309,15 @@
     // NOTE: SimpleDateFormat has an optimization that depends on the fact that min/max integer digits
     // do not affect RBNF (see SimpleDateFormat#zeroPaddingNumber).
     RuleBasedNumberFormat rbnf(URBNF_SPELLOUT, "en", status);
-    rbnf.setMinimumIntegerDigits(2);
-    rbnf.setMaximumIntegerDigits(3);
-    UnicodeString result;
-    rbnf.format(3, result.remove(), status);
-    assertEquals("Min integer digits are ignored", u"three", result);
-    rbnf.format(1012, result.remove(), status);
-    assertEquals("Max integer digits are ignored", u"one thousand twelve", result);
+    if (status.isSuccess()) {
+        rbnf.setMinimumIntegerDigits(2);
+        rbnf.setMaximumIntegerDigits(3);
+        UnicodeString result;
+        rbnf.format(3, result.remove(), status);
+        assertEquals("Min integer digits are ignored", u"three", result);
+        rbnf.format(1012, result.remove(), status);
+        assertEquals("Max integer digits are ignored", u"one thousand twelve", result);
+    }
 }
 
 void 
diff --git a/icu4c/source/test/intltest/itspoof.cpp b/icu4c/source/test/intltest/itspoof.cpp
index 13f9939..4a441dd 100644
--- a/icu4c/source/test/intltest/itspoof.cpp
+++ b/icu4c/source/test/intltest/itspoof.cpp
@@ -648,7 +648,7 @@
 void IntlTestSpoof::testBug12153() {
     UErrorCode status = U_ZERO_ERROR;
     LocalUSpoofCheckerPointer sc(uspoof_open(&status));
-    TEST_ASSERT_SUCCESS(status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     int32_t checks = uspoof_getChecks(sc.getAlias(), &status);
     TEST_ASSERT((checks & USPOOF_RESTRICTION_LEVEL) != 0);
     checks &= ~USPOOF_RESTRICTION_LEVEL;
@@ -688,7 +688,7 @@
 void IntlTestSpoof::testBug13314_MixedNumbers() {
     UErrorCode status = U_ZERO_ERROR;
     LocalUSpoofCheckerPointer sc(uspoof_open(&status));
-    TEST_ASSERT_SUCCESS(status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     uspoof_setChecks(sc.getAlias(), USPOOF_ALL_CHECKS, &status);
     TEST_ASSERT_SUCCESS(status);
     int32_t failedChecks = uspoof_areConfusableUnicodeString(sc.getAlias(), u"列", u"列", &status);
@@ -702,7 +702,7 @@
 void IntlTestSpoof::testBug13328_MixedCombiningMarks() {
     UErrorCode status = U_ZERO_ERROR;
     LocalUSpoofCheckerPointer sc(uspoof_open(&status));
-    TEST_ASSERT_SUCCESS(status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     int32_t failedChecks = uspoof_check2UnicodeString(sc.getAlias(), u"\u0061\u0F84", nullptr, &status);
     TEST_ASSERT_SUCCESS(status);
     assertEquals(
@@ -714,7 +714,7 @@
 void IntlTestSpoof::testCombiningDot() {
     UErrorCode status = U_ZERO_ERROR;
     LocalUSpoofCheckerPointer sc(uspoof_open(&status));
-    TEST_ASSERT_SUCCESS(status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     uspoof_setChecks(sc.getAlias(), USPOOF_HIDDEN_OVERLAY, &status);
     TEST_ASSERT_SUCCESS(status);
 
diff --git a/icu4c/source/test/intltest/numbertest_api.cpp b/icu4c/source/test/intltest/numbertest_api.cpp
index 2885f25..59c0d20 100644
--- a/icu4c/source/test/intltest/numbertest_api.cpp
+++ b/icu4c/source/test/intltest/numbertest_api.cpp
@@ -2338,7 +2338,8 @@
 
     // Default constructors
     LocalizedNumberFormatter l1;
-    assertEquals("Initial behavior", u"10", l1.formatInt(10, status).toString());
+    assertEquals("Initial behavior", u"10", l1.formatInt(10, status).toString(), true);
+    if (status.errDataIfFailureAndReset()) { return; }
     assertEquals("Initial call count", 1, l1.getCallCount());
     assertTrue("Initial compiled", l1.getCompiled() == nullptr);
 
@@ -2414,12 +2415,11 @@
     // Setup:
     LocalUNumberFormatterPointer uformatter(unumf_openForSkeletonAndLocale(u"percent", -1, "en", &ec));
     LocalUFormattedNumberPointer uresult(unumf_openResult(&ec));
-    assertSuccess("", ec, TRUE);
-    if (U_FAILURE(ec)) { return; }
+    if (!assertSuccess("", ec, true, __FILE__, __LINE__)) { return; }
 
     // Format a decimal number:
     unumf_formatDecimal(uformatter.getAlias(), "9.87E-3", -1, uresult.getAlias(), &ec);
-    assertSuccess("", ec);
+    if (!assertSuccess("", ec, true, __FILE__, __LINE__)) { return; }
 
     // Get the location of the percent sign:
     UFieldPosition ufpos = {UNUM_PERCENT_FIELD, 0, 0};
diff --git a/icu4c/source/test/intltest/numbertest_modifiers.cpp b/icu4c/source/test/intltest/numbertest_modifiers.cpp
index e76972b..6d8f199 100644
--- a/icu4c/source/test/intltest/numbertest_modifiers.cpp
+++ b/icu4c/source/test/intltest/numbertest_modifiers.cpp
@@ -101,7 +101,9 @@
 void ModifiersTest::testCurrencySpacingEnabledModifier() {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormatSymbols symbols(Locale("en"), status);
-    assertSuccess("Spot 1", status);
+    if (!assertSuccess("Spot 1", status, true)) {
+        return;
+    }
 
     NumberStringBuilder prefix;
     NumberStringBuilder suffix;
diff --git a/icu4c/source/test/intltest/numbertest_parse.cpp b/icu4c/source/test/intltest/numbertest_parse.cpp
index 14f0018..d5276b4 100644
--- a/icu4c/source/test/intltest/numbertest_parse.cpp
+++ b/icu4c/source/test/intltest/numbertest_parse.cpp
@@ -128,6 +128,9 @@
         LocalPointer<const NumberParserImpl> parser(
                 NumberParserImpl::createSimpleParser(
                         Locale("en"), patternString, parseFlags, status));
+        if (status.errDataIfFailureAndReset("createSimpleParser() failed")) {
+            continue;
+        }
         UnicodeString message =
                 UnicodeString("Input <") + inputString + UnicodeString("> Parser ") + parser->toString();
 
@@ -180,7 +183,9 @@
     IcuTestErrorCode status(*this, "testSeriesMatcher");
 
     DecimalFormatSymbols symbols("en", status);
-
+    if (status.errDataIfFailureAndReset("Failure in DecimalFormtSymbols constructor")) {
+        return;
+    }
     PlusSignMatcher m0(symbols, false);
     MinusSignMatcher m1(symbols, false);
     IgnorablesMatcher m2(unisets::DEFAULT_IGNORABLES);
@@ -237,6 +242,9 @@
     Locale locale = Locale::getEnglish();
 
     DecimalFormatSymbols dfs(locale, status);
+    if (status.errDataIfFailureAndReset("Failure in DecimalFormtSymbols constructor")) {
+        return;
+    }
     dfs.setSymbol(DecimalFormatSymbols::kCurrencySymbol, u"IU$", status);
     dfs.setSymbol(DecimalFormatSymbols::kIntlCurrencySymbol, u"ICU", status);
     CurrencySymbols currencySymbols({u"ICU", status}, locale, dfs, status);
@@ -328,16 +336,17 @@
         bool success;
         AffixPatternMatcher matcher = AffixPatternMatcher::fromAffixPattern(
                 affixPattern, warehouse, parseFlags, &success, status);
-        assertTrue("Creation should be successful", success);
+        if (!status.errDataIfFailureAndReset("Creation should be successful")) {
 
-        // Check that the matcher has the expected number of children
-        assertEquals(affixPattern + " " + cas.exactMatch, cas.expectedMatcherLength, matcher.length());
+            // Check that the matcher has the expected number of children
+            assertEquals(affixPattern + " " + cas.exactMatch, cas.expectedMatcherLength, matcher.length());
 
-        // Check that the matcher works on a sample string
-        StringSegment segment(sampleParseableString, false);
-        ParsedNumber result;
-        matcher.match(segment, result, status);
-        assertEquals(affixPattern + " " + cas.exactMatch, sampleParseableString.length(), result.charEnd);
+            // Check that the matcher works on a sample string
+            StringSegment segment(sampleParseableString, false);
+            ParsedNumber result;
+            matcher.match(segment, result, status);
+            assertEquals(affixPattern + " " + cas.exactMatch, sampleParseableString.length(), result.charEnd);
+        }
     }
 }
 
diff --git a/icu4c/source/test/intltest/numbertest_patternmodifier.cpp b/icu4c/source/test/intltest/numbertest_patternmodifier.cpp
index 13a2554..e3071b3 100644
--- a/icu4c/source/test/intltest/numbertest_patternmodifier.cpp
+++ b/icu4c/source/test/intltest/numbertest_patternmodifier.cpp
@@ -30,7 +30,9 @@
     mod.setPatternAttributes(UNUM_SIGN_AUTO, false);
     DecimalFormatSymbols symbols(Locale::getEnglish(), status);
     CurrencySymbols currencySymbols({u"USD", status}, "en", status);
-    assertSuccess("Spot 2", status);
+    if (!assertSuccess("Spot 2", status, true)) {
+        return;
+    }
     mod.setSymbols(&symbols, &currencySymbols, UNUM_UNIT_WIDTH_SHORT, nullptr);
 
     mod.setNumberProperties(1, StandardPlural::Form::COUNT);
@@ -90,7 +92,9 @@
     mod.setPatternAttributes(UNUM_SIGN_AUTO, false);
     DecimalFormatSymbols symbols(Locale::getEnglish(), status);
     CurrencySymbols currencySymbols({u"USD", status}, "en", status);
-    assertSuccess("Spot 2", status);
+    if (!assertSuccess("Spot 2", status, true)) {
+        return;
+    }
     mod.setSymbols(&symbols, &currencySymbols, UNUM_UNIT_WIDTH_SHORT, nullptr);
     mod.setNumberProperties(1, StandardPlural::Form::COUNT);
 
diff --git a/icu4c/source/test/intltest/numbertest_patternstring.cpp b/icu4c/source/test/intltest/numbertest_patternstring.cpp
index 696e120..b89148d 100644
--- a/icu4c/source/test/intltest/numbertest_patternstring.cpp
+++ b/icu4c/source/test/intltest/numbertest_patternstring.cpp
@@ -23,6 +23,7 @@
 void PatternStringTest::testLocalized() {
     IcuTestErrorCode status(*this, "testLocalized");
     DecimalFormatSymbols symbols(Locale::getEnglish(), status);
+    if (status.isFailure()) { return; }
     symbols.setSymbol(DecimalFormatSymbols::kDecimalSeparatorSymbol, u"a", status);
     symbols.setSymbol(DecimalFormatSymbols::kPercentSymbol, u"b", status);
     symbols.setSymbol(DecimalFormatSymbols::kMinusSignSymbol, u".", status);
diff --git a/icu4c/source/test/intltest/numbertest_skeletons.cpp b/icu4c/source/test/intltest/numbertest_skeletons.cpp
index 6165daf..8ac0529 100644
--- a/icu4c/source/test/intltest/numbertest_skeletons.cpp
+++ b/icu4c/source/test/intltest/numbertest_skeletons.cpp
@@ -5,11 +5,13 @@
 
 #if !UCONFIG_NO_FORMATTING
 
-#include "putilimp.h"
 #include "unicode/dcfmtsym.h"
+
+#include "cstr.h"
 #include "numbertest.h"
 #include "number_utils.h"
 #include "number_skeletons.h"
+#include "putilimp.h"
 
 using namespace icu::number::impl;
 
@@ -109,7 +111,7 @@
         UnicodeString skeletonString(cas);
         status.setScope(skeletonString);
         NumberFormatter::forSkeleton(skeletonString, status);
-        assertSuccess(skeletonString, status);
+        assertSuccess(CStr(skeletonString)(), status, true);
         status.errIfFailureAndReset();
     }
 }
@@ -247,9 +249,11 @@
         UnicodeString expected(cas.expected);
         status.setScope(skeletonString);
         UnicodeString actual = NumberFormatter::forSkeleton(skeletonString, status).locale("en")
-                .formatDouble(5142.3, status)
-                .toString();
-        assertEquals(skeletonString, expected, actual);
+                               .formatDouble(5142.3, status)
+                               .toString();
+        if (!status.errDataIfFailureAndReset()) {
+            assertEquals(skeletonString, expected, actual);
+        }
         status.errIfFailureAndReset();
     }
 }
diff --git a/icu4c/source/test/intltest/numfmtst.cpp b/icu4c/source/test/intltest/numfmtst.cpp
index 6141f45..f5fb64e 100644
--- a/icu4c/source/test/intltest/numfmtst.cpp
+++ b/icu4c/source/test/intltest/numfmtst.cpp
@@ -620,7 +620,7 @@
     // jb 2552
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormat fmt("##0.00E0",status);
-    if (U_SUCCESS(status)) {
+    if (assertSuccess("", status, true, __FILE__, __LINE__)) {
         expect(fmt, .01234, "12.3E-3");
         expect(fmt, .1234, "123E-3");
         expect(fmt, 1.234, "1.23E0");
@@ -1099,7 +1099,7 @@
 
             if (U_FAILURE(status) || n.getType() != Formattable::kLong ||
             	n.getLong() != 1) {
-            	errln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientAffixTestCases[t]
+            	dataerrln((UnicodeString)"Lenient parse failed for \"" + (UnicodeString) lenientAffixTestCases[t]
                       + (UnicodeString) "\"; error code = " + u_errorName(status));
             	status = U_ZERO_ERROR;
             }
@@ -2306,11 +2306,17 @@
     DecimalFormat fmt(ctou("###.###\\u2030"), ec);
     if (!assertSuccess("DecimalFormat ct", ec)) return;
     assertEquals("0.4857 x ###.###\\u2030",
-                 ctou("485.7\\u2030"), fmt.format(0.4857, str));
+                 ctou("485.7\\u2030"), fmt.format(0.4857, str), true);
 
     DecimalFormatSymbols sym(Locale::getUS(), ec);
+    if (!assertSuccess("", ec, true, __FILE__, __LINE__)) {
+        return;
+    }
     sym.setSymbol(DecimalFormatSymbols::kPerMillSymbol, ctou("m"));
     DecimalFormat fmt2("", sym, ec);
+    if (!assertSuccess("", ec, true, __FILE__, __LINE__)) {
+        return;
+    }
     fmt2.applyLocalizedPattern("###.###m", ec);
     if (!assertSuccess("setup", ec)) return;
     str.truncate(0);
@@ -3548,6 +3554,7 @@
     IcuTestErrorCode status(*this, "TestMismatchedCurrencyFormatFail");
     LocalPointer<DecimalFormat> df(
             dynamic_cast<DecimalFormat*>(DecimalFormat::createCurrencyInstance("en", status)), status);
+    if (!assertSuccess("createCurrencyInstance() failed.", status, true, __FILE__, __LINE__)) {return;}
     UnicodeString pattern;
     assertEquals("Test assumes that currency sign is at the beginning",
             u"\u00A4#,##0.00",
@@ -6393,28 +6400,24 @@
 
     Locale locale("en_US");
     for (uint32_t i=0; i<UPRV_LENGTHOF(DATA); ++i) {
-      UnicodeString formatted = ctou(DATA[i]);
-      UErrorCode status = U_ZERO_ERROR;
-      NumberFormat* numFmt = NumberFormat::createInstance(locale, UNUM_CURRENCY, status);
-      // NOTE: ICU 62 requires that the currency format match the pattern in strict mode.
-      numFmt->setLenient(TRUE);
-      if (numFmt != NULL && U_SUCCESS(status)) {
-          ParsePosition parsePos;
-          LocalPointer<CurrencyAmount> currAmt(numFmt->parseCurrency(formatted, parsePos));
-          if (parsePos.getIndex() > 0) {
-              double doubleVal = currAmt->getNumber().getDouble(status);
-              if ( doubleVal != 1.0 ) {
-                  errln("Parsed as currency value other than 1.0: " + formatted + " -> " + doubleVal);
-              }
-          } else {
-              errln("Failed to parse as currency: " + formatted);
-          }
-      } else {
-          dataerrln("Unable to create NumberFormat. - %s", u_errorName(status));
-          delete numFmt;
-          break;
-      }
-      delete numFmt;
+        UnicodeString formatted = ctou(DATA[i]);
+        UErrorCode status = U_ZERO_ERROR;
+        LocalPointer<NumberFormat> numFmt(NumberFormat::createInstance(locale, UNUM_CURRENCY, status), status);
+        if (!assertSuccess("", status, true, __FILE__, __LINE__)) {
+            return;
+        }
+        // NOTE: ICU 62 requires that the currency format match the pattern in strict mode.
+        numFmt->setLenient(TRUE);
+        ParsePosition parsePos;
+        LocalPointer<CurrencyAmount> currAmt(numFmt->parseCurrency(formatted, parsePos));
+        if (parsePos.getIndex() > 0) {
+            double doubleVal = currAmt->getNumber().getDouble(status);
+            if ( doubleVal != 1.0 ) {
+                errln("Parsed as currency value other than 1.0: " + formatted + " -> " + doubleVal);
+            }
+        } else {
+            errln("Failed to parse as currency: " + formatted);
+        }
     }
 
     for (uint32_t i=0; i<UPRV_LENGTHOF(WRONG_DATA); ++i) {
@@ -6815,7 +6818,7 @@
 
     // set the exponent symbol
     status = U_ZERO_ERROR;
-    DecimalFormatSymbols *symbols = new DecimalFormatSymbols(Locale::getDefault(), status);
+    DecimalFormatSymbols symbols(Locale::getDefault(), status);
     if(U_FAILURE(status)) {
         dataerrln((UnicodeString)"ERROR: Could not create DecimalFormatSymbols (Default)");
         return;
@@ -6823,7 +6826,7 @@
 
     // create format instance
     status = U_ZERO_ERROR;
-    DecimalFormat fmt("#####", symbols, status);
+    DecimalFormat fmt(u"#####", symbols, status);
     if(U_FAILURE(status)) {
         errln((UnicodeString)"ERROR: Could not create DecimalFormat (pattern, symbols*)");
     }
@@ -6961,7 +6964,7 @@
     // get some additional case
     {
         UErrorCode status=U_ZERO_ERROR;
-        DecimalFormat df(UnicodeString("0000",""),status);
+        DecimalFormat df(UnicodeString(u"0000"),status);
         if (U_FAILURE(status)) {
             dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
         } else {
@@ -6971,15 +6974,16 @@
             FieldPosition pos;
             df.format(long_number, result, pos);
             if(U_FAILURE(status)||expect!=result) {
-                errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),""));
-            } else {
+                dataerrln("%s:%d FAIL: expected '%s' got '%s' status %s",
+                          __FILE__, __LINE__, CStr(expect)(), CStr(result)(), u_errorName(status));
+             } else {
                 logln("OK:  got expected '"+result+"' status "+UnicodeString(u_errorName(status),""));
             }
         }
     }
     {
         UErrorCode status=U_ZERO_ERROR;
-        DecimalFormat df(UnicodeString("0000000000000000000",""),status);
+        DecimalFormat df(UnicodeString(u"0000000000000000000"),status);
         if (U_FAILURE(status)) {
             dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
         } else {
@@ -6994,7 +6998,8 @@
             FieldPosition pos;
             df.format(long_number, result, pos);
             if(U_FAILURE(status)||expect!=result) {
-                errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775808");
+                dataerrln("%s:%d FAIL: expected '%s' got '%s' status %s on -9223372036854775808",
+                          __FILE__, __LINE__, CStr(expect)(), CStr(result)(), u_errorName(status));
             } else {
                 logln("OK:  got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775808");
             }
@@ -7002,7 +7007,7 @@
     }
     {
         UErrorCode status=U_ZERO_ERROR;
-        DecimalFormat df(UnicodeString("0000000000000000000",""),status);
+        DecimalFormat df(UnicodeString(u"0000000000000000000"),status);
         if (U_FAILURE(status)) {
             dataerrln("Error creating DecimalFormat - %s", u_errorName(status));
         } else {
@@ -7017,7 +7022,8 @@
             FieldPosition pos;
             df.format(long_number, result, pos);
             if(U_FAILURE(status)||expect!=result) {
-                errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on U_INT64_MAX");
+                dataerrln("%s:%d FAIL: expected '%s' got '%s' status %s on U_INT64_MAX",
+                          __FILE__, __LINE__, CStr(expect)(), CStr(result)(), u_errorName(status));
             } else {
                 logln("OK:  got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on U_INT64_MAX");
             }
@@ -7040,7 +7046,8 @@
             FieldPosition pos;
             df.format(long_number, result, pos);
             if(U_FAILURE(status)||expect!=result) {
-                errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on 0");
+                dataerrln("%s:%d FAIL: expected '%s' got '%s' status %s on 0",
+                          __FILE__, __LINE__, CStr(expect)(), CStr(result)(), u_errorName(status));
             } else {
                 logln("OK:  got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on 0");
             }
@@ -7058,7 +7065,8 @@
             FieldPosition pos;
             df.format(long_number, result, pos);
             if(U_FAILURE(status)||expect!=result) {
-                errcheckln(status, "FAIL: expected '"+expect+"' got '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775807");
+                dataerrln("%s:%d FAIL: expected '%s' got '%s' status %s on -9223372036854775807",
+                          __FILE__, __LINE__, CStr(expect)(), CStr(result)(), u_errorName(status));
             } else {
                 logln("OK:  got expected '"+result+"' status "+UnicodeString(u_errorName(status),"")+" on -9223372036854775807");
             }
@@ -7803,12 +7811,12 @@
 void NumberFormatTest::TestZeroScientific10547() {
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormat fmt("0.00E0", status);
-    if (!assertSuccess("Formt creation", status)) {
+    if (!assertSuccess("Format creation", status)) {
         return;
     }
     UnicodeString out;
     fmt.format(-0.0, out);
-    assertEquals("format", "-0.00E0", out);
+    assertEquals("format", "-0.00E0", out, true);
 }
 
 void NumberFormatTest::verifyRounding(
@@ -7827,13 +7835,8 @@
             UnicodeString actual;
             format.format(values[j], actual);
             if (currentExpected != actual) {
-                char buffer[256];
-                sprintf(
-                        buffer,
-                        "For %s value %f, expected ",
-                        descriptions[i],
-                        values[j]);
-                errln(UnicodeString(buffer) + currentExpected + ", got " + actual);
+                dataerrln("For %s value %f, expected '%s', got '%s'",
+                          descriptions[i], values[j], CStr(currentExpected)(), CStr(actual)());
             }
         }
     }
@@ -7862,26 +7865,24 @@
 // for #5186
 void NumberFormatTest::TestEquality() {
     UErrorCode status = U_ZERO_ERROR;
-    DecimalFormatSymbols* symbols = new DecimalFormatSymbols(Locale("root"), status);
+    DecimalFormatSymbols symbols(Locale("root"), status);
     if (U_FAILURE(status)) {
     	dataerrln("Fail: can't create DecimalFormatSymbols for root");
     	return;
     }
     UnicodeString pattern("#,##0.###");
-    DecimalFormat* fmtBase = new DecimalFormat(pattern, symbols, status);
+    DecimalFormat fmtBase(pattern, symbols, status);
     if (U_FAILURE(status)) {
     	dataerrln("Fail: can't create DecimalFormat using root symbols");
     	return;
     }
 
-    DecimalFormat* fmtClone = (DecimalFormat*)fmtBase->clone();
-    fmtClone->setFormatWidth(fmtBase->getFormatWidth() + 32);
-    if (*fmtClone == *fmtBase) {
+    DecimalFormat* fmtClone = (DecimalFormat*)fmtBase.clone();
+    fmtClone->setFormatWidth(fmtBase.getFormatWidth() + 32);
+    if (*fmtClone == fmtBase) {
         errln("Error: DecimalFormat == does not distinguish objects that differ only in FormatWidth");
     }
     delete fmtClone;
-
-    delete fmtBase;
 }
 
 void NumberFormatTest::TestCurrencyUsage() {
@@ -8288,21 +8289,25 @@
 void NumberFormatTest::Test13035_MultiCodePointPaddingInPattern() {
     IcuTestErrorCode status(*this, "Test13035_MultiCodePointPaddingInPattern");
     DecimalFormat df(u"a*'நி'###0b", status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     UnicodeString result;
     df.format(12, result.remove());
     // TODO(13034): Re-enable this test when support is added in ICU4C.
     //assertEquals("Multi-codepoint padding should not be split", u"aநிநி12b", result);
     df = DecimalFormat(u"a*\U0001F601###0b", status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     result = df.format(12, result.remove());
-    assertEquals("Single-codepoint padding should not be split", u"a\U0001F601\U0001F60112b", result);
+    assertEquals("Single-codepoint padding should not be split", u"a\U0001F601\U0001F60112b", result, true);
     df = DecimalFormat(u"a*''###0b", status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     result = df.format(12, result.remove());
-    assertEquals("Quote should be escapable in padding syntax", "a''12b", result);
+    assertEquals("Quote should be escapable in padding syntax", "a''12b", result, true);
 }
 
 void NumberFormatTest::Test13737_ParseScientificStrict() {
     IcuTestErrorCode status(*this, "Test13737_ParseScientificStrict");
-    LocalPointer<NumberFormat> df(NumberFormat::createScientificInstance("en", status));
+    LocalPointer<NumberFormat> df(NumberFormat::createScientificInstance("en", status), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) {return;}
     df->setLenient(FALSE);
     // Parse Test
     expect(*df, u"1.2", 1.2);
@@ -8533,24 +8538,16 @@
 }
 
 void NumberFormatTest::Test11735_ExceptionIssue() {
-    UErrorCode status = U_ZERO_ERROR;
+    IcuTestErrorCode status(*this, "Test11735_ExceptionIssue");
     Locale enLocale("en");
     DecimalFormatSymbols symbols(enLocale, status);
-
-    if (U_FAILURE(status)) {
-      errln((UnicodeString)
-            "Fail: Construct DecimalFormatSymbols");
+    if (status.isSuccess()) {
+        DecimalFormat fmt("0", symbols, status);
+        assertSuccess("Fail: Construct DecimalFormat formatter", status, true, __FILE__, __LINE__);
+        ParsePosition ppos(0);
+        fmt.parseCurrency("53.45", ppos);  // NPE thrown here in ICU4J.
+        assertEquals("Issue11735 ppos", 0, ppos.getIndex());
     }
-
-    DecimalFormat fmt("0", symbols, status);
-    if (U_FAILURE(status)) {
-      errln((UnicodeString)
-            "Fail: Construct DecimalFormat formatter");
-    }
-
-    ParsePosition ppos(0);
-    fmt.parseCurrency("53.45", ppos);  // NPE thrown here in ICU4J.
-    assertEquals("Issue11735 ppos", 0, ppos.getIndex());
 }
 
 void NumberFormatTest::Test11035_FormatCurrencyAmount() {
@@ -8600,8 +8597,9 @@
 
 void NumberFormatTest::TestParsePercentRegression() {
     IcuTestErrorCode status(*this, "TestParsePercentRegression");
-    LocalPointer<DecimalFormat> df1((DecimalFormat*) NumberFormat::createInstance("en", status));
-    LocalPointer<DecimalFormat> df2((DecimalFormat*) NumberFormat::createPercentInstance("en", status));
+    LocalPointer<DecimalFormat> df1((DecimalFormat*) NumberFormat::createInstance("en", status), status);
+    LocalPointer<DecimalFormat> df2((DecimalFormat*) NumberFormat::createPercentInstance("en", status), status);
+    if (status.isFailure()) {return; }
     df1->setLenient(TRUE);
     df2->setLenient(TRUE);
 
@@ -8634,9 +8632,11 @@
 
     // Test magnitude combined with multiplier, as shown in API docs
     DecimalFormat df("0", {"en", status}, status);
-    df.setMultiplier(5);
-    df.setMultiplierScale(-1);
-    expect2(df, 100, u"50"); // round-trip test
+    if (status.isSuccess()) {
+        df.setMultiplier(5);
+        df.setMultiplierScale(-1);
+        expect2(df, 100, u"50"); // round-trip test
+    }
 }
 
 void NumberFormatTest::TestFastFormatInt32() {
@@ -8645,7 +8645,8 @@
     // The two simplest formatters, old API and new API.
     // Old API should use the fastpath for ints.
     LocalizedNumberFormatter lnf = NumberFormatter::withLocale("en");
-    LocalPointer<NumberFormat> df(NumberFormat::createInstance("en", status));
+    LocalPointer<NumberFormat> df(NumberFormat::createInstance("en", status), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) {return;}
 
     double nums[] = {
             0.0,
@@ -8727,6 +8728,7 @@
     IcuTestErrorCode status(*this, "TestParseNaN");
 
     DecimalFormat df("0", { "en", status }, status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     Formattable parseResult;
     df.parse(u"NaN", parseResult, status);
     assertEquals("NaN should parse successfully", NAN, parseResult.getDouble());
@@ -8754,6 +8756,7 @@
         DecimalFormatSymbols dfs("en", status);
         dfs.setSymbol(DecimalFormatSymbols::kPatternSeparatorSymbol, u"!", FALSE);
         DecimalFormat df(u"0", dfs, status);
+        if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
         df.applyPattern("a0;b0", status); // should not throw
         UnicodeString result;
         assertEquals("should apply the normal pattern",
@@ -8783,7 +8786,8 @@
 void NumberFormatTest::Test11839() {
     IcuTestErrorCode errorCode(*this, "Test11839");
     // Ticket #11839: DecimalFormat does not respect custom plus sign
-    LocalPointer<DecimalFormatSymbols> dfs(new DecimalFormatSymbols(Locale::getEnglish(), errorCode));
+    LocalPointer<DecimalFormatSymbols> dfs(new DecimalFormatSymbols(Locale::getEnglish(), errorCode), errorCode);
+    if (!assertSuccess("", errorCode, true, __FILE__, __LINE__)) { return; }
     dfs->setSymbol(DecimalFormatSymbols::kMinusSignSymbol, u"a∸");
     dfs->setSymbol(DecimalFormatSymbols::kPlusSignSymbol, u"b∔"); //  ∔  U+2214 DOT PLUS
     DecimalFormat df(u"0.00+;0.00-", dfs.orphan(), errorCode);
@@ -8818,7 +8822,8 @@
 void NumberFormatTest::Test11645_ApplyPatternEquality() {
     IcuTestErrorCode status(*this, "Test11645_ApplyPatternEquality");
     const char16_t* pattern = u"#,##0.0#";
-    LocalPointer<DecimalFormat> fmt((DecimalFormat*) NumberFormat::createInstance(status));
+    LocalPointer<DecimalFormat> fmt((DecimalFormat*) NumberFormat::createInstance(status), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     fmt->applyPattern(pattern, status);
     LocalPointer<DecimalFormat> fmtCopy;
 
@@ -8866,6 +8871,7 @@
         NumberFormat::createInstance(Locale::getUS(), UNUM_CURRENCY, errorCode));
     LocalPointer<DecimalFormat> df2((DecimalFormat *)
         NumberFormat::createInstance(Locale::getUS(), UNUM_DECIMAL, errorCode));
+    if (!assertSuccess("", errorCode, true, __FILE__, __LINE__)) { return; }
     // NOTE: CurrencyPluralInfo equality not tested in C++ because its operator== is not defined.
     df1->applyPattern(u"0.00", errorCode);
     df2->applyPattern(u"0.00", errorCode);
@@ -8882,8 +8888,9 @@
     // change formatting spelled out currencies
     // Use locale sr because it has interesting plural rules.
     Locale locale("sr");
-    LocalPointer<DecimalFormatSymbols> symbols(new DecimalFormatSymbols(locale, errorCode));
+    LocalPointer<DecimalFormatSymbols> symbols(new DecimalFormatSymbols(locale, errorCode), errorCode);
     CurrencyPluralInfo info(locale, errorCode);
+    if (!assertSuccess("", errorCode, true, __FILE__, __LINE__)) { return; }
     info.setCurrencyPluralPattern(u"one", u"0 qwerty", errorCode);
     info.setCurrencyPluralPattern(u"few", u"0 dvorak", errorCode);
     DecimalFormat df(u"#", symbols.orphan(), UNUM_CURRENCY_PLURAL, errorCode);
@@ -8934,6 +8941,7 @@
     UErrorCode status = U_ZERO_ERROR;
 
     DecimalFormat fmt("0.00", {"en", status}, status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     fmt.setScientificNotation(TRUE);
     UnicodeString pattern;
 
@@ -8950,6 +8958,7 @@
     UnicodeString pattern("\\u00a4\\u00a4\\u00a4 0.00");
     pattern = pattern.unescape();
     DecimalFormat fmt(pattern, status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     static const UChar USD[] = u"USD";
     fmt.setCurrency(USD);
     UnicodeString appendTo;
@@ -8968,7 +8977,8 @@
 void NumberFormatTest::Test13148_ParseGroupingSeparators() {
   IcuTestErrorCode status(*this, "Test13148");
   LocalPointer<DecimalFormat> fmt(
-      (DecimalFormat*)NumberFormat::createInstance("en-ZA", status));
+      (DecimalFormat*)NumberFormat::createInstance("en-ZA", status), status);
+  if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
 
   DecimalFormatSymbols symbols = *fmt->getDecimalFormatSymbols();
 
@@ -9018,6 +9028,7 @@
     UErrorCode status = U_ZERO_ERROR;
     DecimalFormatSymbols sym(Locale::getFrance(), status);
     DecimalFormat fmt(u"0.05E0", sym, status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     assertSuccess("", status);
     UnicodeString result;
     fmt.format(12301.2, result);
@@ -9044,7 +9055,8 @@
     IcuTestErrorCode status(*this, "Test13763_FieldPositionIteratorOffset");
     FieldPositionIterator fpi;
     UnicodeString result(u"foo\U0001F4FBbar"); // 8 code units
-    LocalPointer<NumberFormat> nf(NumberFormat::createInstance("en", status));
+    LocalPointer<NumberFormat> nf(NumberFormat::createInstance("en", status), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     nf->format(5142.3, result, &fpi, status);
 
     int32_t expected[] = {
@@ -9061,7 +9073,8 @@
     IcuTestErrorCode status(*this, "Test13777_ParseLongNameNonCurrencyMode");
 
     LocalPointer<NumberFormat> df(
-        NumberFormat::createInstance("en-us", UNumberFormatStyle::UNUM_CURRENCY_PLURAL, status));
+        NumberFormat::createInstance("en-us", UNumberFormatStyle::UNUM_CURRENCY_PLURAL, status), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
     expect2(*df, 1.5, u"1.50 US dollars");
 }
 
diff --git a/icu4c/source/test/intltest/numrgts.cpp b/icu4c/source/test/intltest/numrgts.cpp
index 2c2ebbb..4827045 100644
--- a/icu4c/source/test/intltest/numrgts.cpp
+++ b/icu4c/source/test/intltest/numrgts.cpp
@@ -22,6 +22,7 @@
 #include "unicode/datefmt.h"
 #include "unicode/ucurr.h"
 #include "cmemory.h"
+#include "cstr.h"
 #include "putilimp.h"
 #include "uassert.h"
 
@@ -1177,30 +1178,28 @@
 void NumberFormatRegressionTest::Test4093610(void)
 {
     UErrorCode status = U_ZERO_ERROR;
-    DecimalFormat *df = new DecimalFormat("#0.#", status);
+    DecimalFormat df("#0.#", status);
     if (!failure(status, "new DecimalFormat")) {
         UnicodeString s("12.4");
-        roundingTest(df, 12.35, s);
-        roundingTest(df, 12.45, s);
+        roundingTest(&df, 12.35, s);
+        roundingTest(&df, 12.45, s);
         s = "12.5";
-        roundingTest(df, 12.452,s);
+        roundingTest(&df, 12.452,s);
         s = "12.6";
-        roundingTest(df, 12.55, s);
-        roundingTest(df, 12.65, s);
+        roundingTest(&df, 12.55, s);
+        roundingTest(&df, 12.65, s);
         s = "12.7";
-        roundingTest(df, 12.652,s);
+        roundingTest(&df, 12.652,s);
         s = "12.8";
-        roundingTest(df, 12.75, s);
-        roundingTest(df, 12.752,s);
-        roundingTest(df, 12.85, s);
+        roundingTest(&df, 12.75, s);
+        roundingTest(&df, 12.752,s);
+        roundingTest(&df, 12.85, s);
         s = "12.9";
-        roundingTest(df, 12.852,s);
+        roundingTest(&df, 12.852,s);
         s = "13";
-        roundingTest(df, 12.95, s);
-        roundingTest(df, 12.952,s);
+        roundingTest(&df, 12.95, s);
+        roundingTest(&df, 12.952,s);
     }
-
-    delete df;
 }
 
 void NumberFormatRegressionTest::roundingTest(DecimalFormat *df, double x, UnicodeString& expected)
@@ -1209,8 +1208,9 @@
     FieldPosition pos(FieldPosition::DONT_CARE);
     out = df->format(x, out, pos);
     logln(UnicodeString("") + x + " formats with 1 fractional digits to " + out);
-    if (out != expected) 
-        errln("FAIL: Expected " + expected);
+    if (out != expected) {
+        dataerrln("FAIL: Expected '%s'; got '%s'", CStr(expected)(), CStr(out)());
+    }
 }
 /* @bug 4098741
  * Tests the setMaximumFractionDigits limit.
@@ -1892,9 +1892,11 @@
 void NumberFormatRegressionTest::Test4140009(void) 
 {
     UErrorCode status = U_ZERO_ERROR;
-    DecimalFormatSymbols *syms = new DecimalFormatSymbols(Locale::getEnglish(), status);
-    failure(status, "new DecimalFormatSymbols");
-    DecimalFormat *f = new DecimalFormat(UnicodeString(""), syms, status);
+    LocalPointer<DecimalFormatSymbols> syms(new DecimalFormatSymbols(Locale::getEnglish(), status), status);
+    if (failure(status, "new DecimalFormatSymbols")) {
+        return;
+    }
+    DecimalFormat *f = new DecimalFormat(UnicodeString(u""), syms.orphan(), status);
     if (!failure(status, "new DecimalFormat")) {
         UnicodeString s;
         FieldPosition pos(FieldPosition::DONT_CARE);
@@ -2216,6 +2218,9 @@
     IcuTestErrorCode status(*this, "Test4170798");
     LocalPointer<DecimalFormat> df(dynamic_cast<DecimalFormat*>(
             NumberFormat::createInstance(Locale::getUS(), status)), status);
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) {
+        return;
+    }
     {
         Formattable n;
         ParsePosition pos(0);
diff --git a/icu4c/source/test/intltest/rbbimonkeytest.cpp b/icu4c/source/test/intltest/rbbimonkeytest.cpp
index 30755b3..f4fb701 100644
--- a/icu4c/source/test/intltest/rbbimonkeytest.cpp
+++ b/icu4c/source/test/intltest/rbbimonkeytest.cpp
@@ -931,9 +931,9 @@
     int32_t i;
     for (i=0; tests[i] != NULL; ++i) {
         logln("beginning testing of %s", tests[i]);
-        RBBIMonkeyImpl *test = new RBBIMonkeyImpl(status);
+        LocalPointer<RBBIMonkeyImpl> test(new RBBIMonkeyImpl(status));
         if (U_FAILURE(status)) {
-            errln("%s:%d: error %s while starting test %s.", __FILE__, __LINE__, u_errorName(status), tests[i]);
+            dataerrln("%s:%d: error %s while starting test %s.", __FILE__, __LINE__, u_errorName(status), tests[i]);
             break;
         }
         test->fDumpExpansions = dumpExpansions;
@@ -942,11 +942,11 @@
         test->fLoopCount = loopCount;
         test->setup(tests[i], status);
         if (U_FAILURE(status)) {
-            errln("%s:%d: error %s while starting test %s.", __FILE__, __LINE__, u_errorName(status), tests[i]);
+            dataerrln("%s:%d: error %s while starting test %s.", __FILE__, __LINE__, u_errorName(status), tests[i]);
             break;
         }
         test->startTest();
-        startedTests.addElement(test, status);
+        startedTests.addElement(test.orphan(), status);
         if (U_FAILURE(status)) {
             errln("%s:%d: error %s while starting test %s.", __FILE__, __LINE__, u_errorName(status), tests[i]);
             break;
diff --git a/icu4c/source/test/intltest/rbbitst.cpp b/icu4c/source/test/intltest/rbbitst.cpp
index 40ab201..5463dad 100644
--- a/icu4c/source/test/intltest/rbbitst.cpp
+++ b/icu4c/source/test/intltest/rbbitst.cpp
@@ -1059,7 +1059,7 @@
 
 
         if (U_FAILURE(status)) {
-            errln("ICU Error %s while parsing test file at line %d.",
+            dataerrln("ICU Error %s while parsing test file at line %d.",
                 u_errorName(status), lineNum);
             status = U_ZERO_ERROR;
             goto end_test; // Stop the test
@@ -4472,21 +4472,23 @@
 
     TestReverse(std::unique_ptr<RuleBasedBreakIterator>((RuleBasedBreakIterator *)
             BreakIterator::createCharacterInstance(Locale::getEnglish(), status)));
-    assertSuccess(WHERE, status);
+    assertSuccess(WHERE, status, true);
+    status = U_ZERO_ERROR;
     TestReverse(std::unique_ptr<RuleBasedBreakIterator>((RuleBasedBreakIterator *)
             BreakIterator::createWordInstance(Locale::getEnglish(), status)));
-    assertSuccess(WHERE, status);
+    assertSuccess(WHERE, status, true);
+    status = U_ZERO_ERROR;
     TestReverse(std::unique_ptr<RuleBasedBreakIterator>((RuleBasedBreakIterator *)
             BreakIterator::createLineInstance(Locale::getEnglish(), status)));
-    assertSuccess(WHERE, status);
+    assertSuccess(WHERE, status, true);
+    status = U_ZERO_ERROR;
     TestReverse(std::unique_ptr<RuleBasedBreakIterator>((RuleBasedBreakIterator *)
             BreakIterator::createSentenceInstance(Locale::getEnglish(), status)));
-    assertSuccess(WHERE, status);
+    assertSuccess(WHERE, status, true);
 }
 
 void RBBITest::TestReverse(std::unique_ptr<RuleBasedBreakIterator>bi) {
     if (!bi) {
-        errln(WHERE);
         return;
     }
 
@@ -4546,6 +4548,9 @@
     UErrorCode status = U_ZERO_ERROR;
     LocalPointer<RuleBasedBreakIterator> bi ((RuleBasedBreakIterator *)
             BreakIterator::createWordInstance(Locale::getEnglish(), status), status);
+    if (!assertSuccess(WHERE, status, true)) {
+        return;
+    }
     constexpr int32_t LENGTH = 1000000;
     UnicodeString longNumber(LENGTH, (UChar32)u'3', LENGTH);
     for (int i=0; i<20; i+=2) {
@@ -4565,6 +4570,9 @@
     UErrorCode status = U_ZERO_ERROR;
     LocalPointer<RuleBasedBreakIterator> bi ((RuleBasedBreakIterator *)
             BreakIterator::createCharacterInstance(Locale::getEnglish(), status), status);
+    if (!assertSuccess(WHERE, status, true)) {
+        return;
+    }
     const UnicodeString &rules = bi->getRules();
     UParseError pe;
     LocalPointer<RuleBasedBreakIterator> newbi(new RuleBasedBreakIterator(rules, pe, status));
diff --git a/icu4c/source/test/intltest/testidna.cpp b/icu4c/source/test/intltest/testidna.cpp
index acda1f6..e5eb44e 100644
--- a/icu4c/source/test/intltest/testidna.cpp
+++ b/icu4c/source/test/intltest/testidna.cpp
@@ -473,6 +473,10 @@
 
     // test null-terminated source and return value of number of UChars required
     destLen = func(src,-1,NULL,0,options, &parseError , &status);
+    if (status == U_FILE_ACCESS_ERROR) {
+        dataerrln("U_FILE_ACCESS_ERROR. Skipping the remainder of this test.");
+        return;
+    }
     if(status == U_BUFFER_OVERFLOW_ERROR){
         status = U_ZERO_ERROR; // reset error code
         if(destLen+1 < MAX_DEST_SIZE){
@@ -1297,17 +1301,25 @@
     testIDNToUnicode("uidna_IDNToUnicode", uidna_IDNToUnicode);
 }
 void TestIDNA::TestCompare(){
-    testCompare("uidna_compare",uidna_compare);
+    UErrorCode status = U_ZERO_ERROR;
+    uidna_close(uidna_openUTS46(0, &status));   // Fail quickly if no data.
+    if (assertSuccess("", status, true, __FILE__, __LINE__)) {
+        testCompare("uidna_compare",uidna_compare);
+    }
 }
 void TestIDNA::TestErrorCases(){
     testErrorCases( "uidna_IDNToASCII",uidna_IDNToASCII,
                     "uidna_IDNToUnicode",uidna_IDNToUnicode);
 }
 void TestIDNA::TestRootLabelSeparator(){
-    testRootLabelSeparator( "uidna_compare",uidna_compare,
-                            "uidna_IDNToASCII", uidna_IDNToASCII,
-                            "uidna_IDNToUnicode",uidna_IDNToUnicode
-                            );
+    UErrorCode status = U_ZERO_ERROR;
+    uidna_close(uidna_openUTS46(0, &status));   // Fail quickly if no data.
+    if (assertSuccess("", status, true, __FILE__, __LINE__)) {
+        testRootLabelSeparator( "uidna_compare",uidna_compare,
+                                "uidna_IDNToASCII", uidna_IDNToASCII,
+                                "uidna_IDNToUnicode",uidna_IDNToUnicode
+                              );
+    }
 }
 void TestIDNA::TestChaining(){
     testChaining("uidna_toASCII",uidna_toASCII, "uidna_toUnicode", uidna_toUnicode);
@@ -1529,14 +1541,14 @@
     int32_t srcLen = 0;
 
     // data even OK?
-    {
-      UErrorCode dataStatus = U_ZERO_ERROR;
-      loadTestData(dataStatus);
-      if(U_FAILURE(dataStatus)) {
+    UErrorCode dataStatus = U_ZERO_ERROR;
+    loadTestData(dataStatus);
+    if(U_FAILURE(dataStatus)) {
         dataerrln("Couldn't load test data: %s\n", u_errorName(dataStatus)); // save us from thousands and thousands of errors
         return;
-      }
     }
+    uidna_close(uidna_openUTS46(0, &dataStatus));   // Fail quickly if no data.
+    if (!assertSuccess("", dataStatus, true, __FILE__, __LINE__)) { return; }
 
     for (int32_t i = 0; i <= 0x10FFFF; i++){
         if (quick == TRUE && i > 0x0FFF){
@@ -1561,13 +1573,9 @@
 
 void TestIDNA::TestRefIDNA(){
     UErrorCode status = U_ZERO_ERROR;
-    getInstance(status);    // Init prep
-    if (U_FAILURE(status)) {
-        if (status == U_FILE_ACCESS_ERROR) {
-            dataerrln("Test could not initialize. Got %s", u_errorName(status));
-        }
-        return;
-    }
+
+    getInstance(status);    // Init prep. Abort test early if no data.
+    if (!assertSuccess("", status, true, __FILE__, __LINE__)) { return; }
 
     testToASCII("idnaref_toASCII", idnaref_toASCII);
     testToUnicode("idnaref_toUnicode", idnaref_toUnicode);