diff --git a/icu4c/source/i18n/measunit_extra.cpp b/icu4c/source/i18n/measunit_extra.cpp
index 06bf90b..676ff88 100644
--- a/icu4c/source/i18n/measunit_extra.cpp
+++ b/icu4c/source/i18n/measunit_extra.cpp
@@ -894,6 +894,12 @@ SingleUnitImpl SingleUnitImpl::forMeasureUnit(const MeasureUnit& measureUnit, UE
 MeasureUnit SingleUnitImpl::build(UErrorCode& status) const {
     MeasureUnitImpl temp;
     temp.appendSingleUnit(*this, status);
+    // TODO(icu-units#28): the MeasureUnitImpl::build() method uses
+    // findBySubtype, which is relatively slow.
+    // - At the time of loading the simple unit IDs, we could also save a
+    //   mapping to the builtin MeasureUnit type and subtype they correspond to.
+    // - This method could then check dimensionality and index, and if both are
+    //   1, directly return MeasureUnit instances very quickly.
     return std::move(temp).build(status);
 }
 
diff --git a/icu4c/source/i18n/measunit_impl.h b/icu4c/source/i18n/measunit_impl.h
index 645e821..6c5a5ac 100644
--- a/icu4c/source/i18n/measunit_impl.h
+++ b/icu4c/source/i18n/measunit_impl.h
@@ -14,6 +14,12 @@
 
 U_NAMESPACE_BEGIN
 
+namespace number {
+namespace impl {
+class LongNameHandler;
+}
+} // namespace number
+
 // Export an explicit template instantiation of the LocalPointer that is used as a
 // data member of MeasureUnitImpl.
 // (When building DLLs for Windows this is required.)
@@ -310,6 +316,10 @@ class U_I18N_API MeasureUnitImpl : public UMemory {
      * Normalizes a MeasureUnitImpl and generate the identifier string in place.
      */
     void serialize(UErrorCode &status);
+
+    // For calling serialize
+    // TODO(icu-units#147): revisit serialization
+    friend class number::impl::LongNameHandler;
 };
 
 U_NAMESPACE_END
diff --git a/icu4c/source/i18n/number_formatimpl.cpp b/icu4c/source/i18n/number_formatimpl.cpp
index fb0eec9..eb904dc 100644
--- a/icu4c/source/i18n/number_formatimpl.cpp
+++ b/icu4c/source/i18n/number_formatimpl.cpp
@@ -375,7 +375,7 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
 
     // Outer modifier (CLDR units and currency long names)
     if (isCldrUnit) {
-        StringPiece unitDisplayCase("");
+        const char *unitDisplayCase = "";
         if (macros.unitDisplayCase.isSet()) {
             unitDisplayCase = macros.unitDisplayCase.fValue;
         }
@@ -398,6 +398,16 @@ NumberFormatterImpl::macrosToMicroGenerator(const MacroProps& macros, bool safe,
             MeasureUnit unit = macros.unit;
             if (!utils::unitIsBaseUnit(macros.perUnit)) {
                 unit = unit.product(macros.perUnit.reciprocal(status), status);
+                // This isn't strictly necessary, but was what we specced out
+                // when perUnit became a backward-compatibility thing:
+                // unit/perUnit use case is only valid if both units are
+                // built-ins, or the product is a built-in.
+                if (uprv_strcmp(unit.getType(), "") == 0 &&
+                    (uprv_strcmp(macros.unit.getType(), "") == 0 ||
+                     uprv_strcmp(macros.perUnit.getType(), "") == 0)) {
+                    status = U_UNSUPPORTED_ERROR;
+                    return nullptr;
+                }
             }
             fLongNameHandler.adoptInsteadAndCheckErrorCode(new LongNameHandler(), status);
             LongNameHandler::forMeasureUnit(macros.locale, unit, unitWidth, unitDisplayCase,
diff --git a/icu4c/source/i18n/number_longnames.cpp b/icu4c/source/i18n/number_longnames.cpp
index e740272..41d0e7c 100644
--- a/icu4c/source/i18n/number_longnames.cpp
+++ b/icu4c/source/i18n/number_longnames.cpp
@@ -46,13 +46,19 @@ constexpr int32_t GENDER_INDEX = StandardPlural::Form::COUNT + 2;
 // Number of keys in the array populated by PluralTableSink.
 constexpr int32_t ARRAY_LENGTH = StandardPlural::Form::COUNT + 3;
 
-// TODO(inflections): load this list from resources, after creating a "&set"
+// TODO(icu-units#28): load this list from resources, after creating a "&set"
 // function for use in ldml2icu rules.
 const int32_t GENDER_COUNT = 7;
 const char *gGenders[GENDER_COUNT] = {"animate",   "common", "feminine", "inanimate",
                                       "masculine", "neuter", "personal"};
 
+// Converts a UnicodeString to a const char*, either pointing to a string in
+// gGenders, or pointing to an empty string if an appropriate string was not
+// found.
 const char *getGenderString(UnicodeString uGender, UErrorCode status) {
+    if (uGender.length() == 0) {
+        return "";
+    }
     CharString gender;
     gender.appendInvariantChars(uGender, status);
     if (U_FAILURE(status)) {
@@ -71,9 +77,16 @@ const char *getGenderString(UnicodeString uGender, UErrorCode status) {
             last = mid;
         }
     }
+    // We don't return an error in case our gGenders list is incomplete in
+    // production.
+    //
+    // TODO(icu-units#28): a unit test checking all locales' genders are covered
+    // by gGenders? Else load a complete list of genders found in
+    // grammaticalFeatures in an initOnce.
     return "";
 }
 
+// Returns the array index that corresponds to the given pluralKeyword.
 static int32_t getIndex(const char* pluralKeyword, UErrorCode& status) {
     // pluralKeyword can also be "dnam", "per", or "gender"
     switch (*pluralKeyword) {
@@ -119,13 +132,248 @@ static UnicodeString getWithPlural(
     return result;
 }
 
+enum PlaceholderPosition { PH_EMPTY, PH_NONE, PH_BEGINNING, PH_MIDDLE, PH_END };
+
+/**
+ * Returns three outputs extracted from pattern.
+ *
+ * @param coreUnit is extracted as per Extract(...) in the spec:
+ *   https://unicode.org/reports/tr35/tr35-general.html#compound-units
+ * @param PlaceholderPosition indicates where in the string the placeholder was
+ *   found.
+ * @param joinerChar Iff the placeholder was at the beginning or end, joinerChar
+ *   contains the space character (if any) that separated the placeholder from
+ *   the rest of the pattern. Otherwise, joinerChar is set to NUL.
+ */
+void extractCorePattern(const UnicodeString &pattern,
+                        UnicodeString &coreUnit,
+                        PlaceholderPosition &placeholderPosition,
+                        UChar &joinerChar) {
+    joinerChar = 0;
+    if (pattern.startsWith(u"{0}", 3)) {
+        placeholderPosition = PH_BEGINNING;
+        if (u_isJavaSpaceChar(pattern[3])) {
+            joinerChar = pattern[3];
+            coreUnit.setTo(pattern, 4, pattern.length() - 4);
+            // Expecting no double spaces
+            U_ASSERT(!u_isJavaSpaceChar(pattern[4]));
+        } else {
+            coreUnit.setTo(pattern, 3, pattern.length() - 3);
+        }
+    } else if (pattern.endsWith(u"{0}", 3)) {
+        placeholderPosition = PH_END;
+        int32_t len = pattern.length();
+        if (u_isJavaSpaceChar(pattern[len - 4])) {
+            coreUnit.setTo(pattern, 0, pattern.length() - 4);
+            joinerChar = pattern[len - 4];
+            // Expecting no double spaces
+            U_ASSERT(!u_isJavaSpaceChar(pattern[len - 5]));
+        } else {
+            coreUnit.setTo(pattern, 0, pattern.length() - 3);
+        }
+    } else if (pattern.indexOf(u"{0}", 0, 1, pattern.length() - 2) == -1) {
+        placeholderPosition = PH_NONE;
+        coreUnit = pattern;
+    } else {
+        placeholderPosition = PH_MIDDLE;
+        coreUnit = pattern;
+    }
+}
 
 //////////////////////////
 /// BEGIN DATA LOADING ///
 //////////////////////////
 
+// Gets the gender of a built-in unit: unit must be a built-in. Returns an empty
+// string both in case of unknown gender and in case of unknown unit.
+const char *getGenderForBuiltin(const Locale &locale, MeasureUnit builtinUnit, UErrorCode &status) {
+    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
+    if (U_FAILURE(status)) { return ""; }
+
+    // Map duration-year-person, duration-week-person, etc. to duration-year, duration-week, ...
+    // TODO(ICU-20400): Get duration-*-person data properly with aliases.
+    StringPiece subtypeForResource;
+    int32_t subtypeLen = static_cast<int32_t>(uprv_strlen(builtinUnit.getSubtype()));
+    if (subtypeLen > 7 && uprv_strcmp(builtinUnit.getSubtype() + subtypeLen - 7, "-person") == 0) {
+        subtypeForResource = {builtinUnit.getSubtype(), subtypeLen - 7};
+    } else {
+        subtypeForResource = builtinUnit.getSubtype();
+    }
+
+    CharString key;
+    key.append("units/", status);
+    key.append(builtinUnit.getType(), status);
+    key.append("/", status);
+    key.append(subtypeForResource, status);
+    key.append("/gender", status);
+
+    UErrorCode localStatus = status;
+    StackUResourceBundle fillIn;
+    ures_getByKeyWithFallback(unitsBundle.getAlias(), key.data(), fillIn.getAlias(), &localStatus);
+    if (U_SUCCESS(localStatus)) {
+        status = localStatus;
+        UnicodeString directString = ures_getUnicodeString(fillIn.getAlias(), &status);
+        return getGenderString(directString, status);
+    } else {
+        // TODO(icu-units#28): "$unitRes/gender" does not exist. Do we want to
+        // check whether the parent "$unitRes" exists? Then we could return
+        // U_MISSING_RESOURCE_ERROR for incorrect usage (e.g. builtinUnit not
+        // being a builtin).
+        return "";
+    }
+}
+
+// Loads data from a resource tree with paths matching
+// $key/$pluralForm/$gender/$case, with lateral inheritance for missing cases
+// and genders.
+//
+// An InflectedPluralSink is configured to load data for a specific gender and
+// case. It loads all plural forms, because selection between plural forms is
+// dependent upon the value being formatted.
+//
+// TODO(icu-units#138): Conceptually similar to PluralTableSink, however the
+// tree structures are different. After homogenizing the structures, we may be
+// able to unify the two classes.
+//
+// TODO: Spec violation: expects presence of "count" - does not fallback to an
+// absent "count"! If this fallback were added, getCompoundValue could be
+// superseded?
+class InflectedPluralSink : public ResourceSink {
+  public:
+    // Accepts `char*` rather than StringPiece because
+    // ResourceTable::findValue(...) requires a null-terminated `char*`.
+    //
+    // NOTE: outArray MUST have a length of at least ARRAY_LENGTH. No bounds
+    // checking is performed.
+    explicit InflectedPluralSink(const char *gender, const char *caseVariant, UnicodeString *outArray)
+        : gender(gender), caseVariant(caseVariant), outArray(outArray) {
+        // Initialize the array to bogus strings.
+        for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
+            outArray[i].setToBogus();
+        }
+    }
+
+    // See ResourceSink::put().
+    void put(const char *key, ResourceValue &value, UBool /*noFallback*/, UErrorCode &status) U_OVERRIDE {
+        ResourceTable pluralsTable = value.getTable(status);
+        if (U_FAILURE(status)) { return; }
+        for (int32_t i = 0; pluralsTable.getKeyAndValue(i, key, value); ++i) {
+            int32_t pluralIndex = getIndex(key, status);
+            if (U_FAILURE(status)) { return; }
+            if (!outArray[pluralIndex].isBogus()) {
+                // We already have a pattern
+                continue;
+            }
+            ResourceTable genderTable = value.getTable(status);
+            if (loadForPluralForm(genderTable, value, status)) {
+                outArray[pluralIndex] = value.getUnicodeString(status);
+            }
+        }
+    }
+
+  private:
+    // Tries to load data for the configured gender from `genderTable`. Returns
+    // true if found, returning the data in `value`. The returned data will be
+    // for the configured gender if found, falling back to "neuter" and
+    // no-gender if not.
+    bool loadForPluralForm(const ResourceTable &genderTable, ResourceValue &value, UErrorCode &status) {
+        if (uprv_strcmp(gender, "") != 0) {
+            if (loadForGender(genderTable, gender, value, status)) {
+                return true;
+            }
+            if (uprv_strcmp(gender, "neuter") != 0 && loadForGender(genderTable, "neuter", value, status)) {
+                return true;
+            }
+        }
+        if (loadForGender(genderTable, "_", value, status)) {
+            return true;
+        }
+        return false;
+    }
+
+    // Tries to load data for the given gender from `genderTable`. Returns true
+    // if found, returning the data in `value`. The returned data will be for
+    // the configured case if found, falling back to "nominative" and no-case if
+    // not.
+    bool loadForGender(const ResourceTable &genderTable,
+                   const char *genderVal,
+                   ResourceValue &value,
+                   UErrorCode &status) {
+        if (!genderTable.findValue(genderVal, value)) {
+            return false;
+        }
+        ResourceTable caseTable = value.getTable(status);
+        if (uprv_strcmp(caseVariant, "") != 0) {
+            if (loadForCase(caseTable, caseVariant, value)) {
+                return true;
+            }
+            if (uprv_strcmp(caseVariant, "nominative") != 0 &&
+                loadForCase(caseTable, "nominative", value)) {
+                return true;
+            }
+        }
+        if (loadForCase(caseTable, "_", value)) {
+            return true;
+        }
+        return false;
+    }
+
+    // Tries to load data for the given case from `caseTable`. Returns true if
+    // found, returning the data in `value`.
+    bool loadForCase(const ResourceTable &caseTable,
+                 const char *caseValue,
+                 ResourceValue &value) {
+        if (!caseTable.findValue(caseValue, value)) {
+            return false;
+        }
+        return true;
+    }
+
+    const char *gender;
+    const char *caseVariant;
+    UnicodeString *outArray;
+};
+
+void getInflectedMeasureData(StringPiece subKey,
+                             const Locale &locale,
+                             const UNumberUnitWidth &width,
+                             const char *gender,
+                             const char *caseVariant,
+                             UnicodeString *outArray,
+                             UErrorCode &status) {
+    InflectedPluralSink sink(gender, caseVariant, outArray);
+    LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
+    if (U_FAILURE(status)) { return; }
+
+    CharString key;
+    key.append("units", status);
+    if (width == UNUM_UNIT_WIDTH_NARROW) {
+        key.append("Narrow", status);
+    } else if (width == UNUM_UNIT_WIDTH_SHORT) {
+        key.append("Short", status);
+    }
+    key.append("/", status);
+    key.append(subKey, status);
+
+    UErrorCode localStatus = status;
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
+    if (width == UNUM_UNIT_WIDTH_SHORT) {
+        status = localStatus;
+        return;
+    }
+
+    // TODO(ICU-13353): The fallback to short does not work in ICU4C.
+    // Manually fall back to short (this is done automatically in Java).
+    key.clear();
+    key.append("unitsShort/", status);
+    key.append(subKey, status);
+    ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
+}
+
 class PluralTableSink : public ResourceSink {
   public:
+    // NOTE: outArray MUST have a length of at least ARRAY_LENGTH. No bounds
+    // checking is performed.
     explicit PluralTableSink(UnicodeString *outArray) : outArray(outArray) {
         // Initialize the array to bogus strings.
         for (int32_t i = 0; i < ARRAY_LENGTH; i++) {
@@ -154,8 +402,6 @@ class PluralTableSink : public ResourceSink {
     UnicodeString *outArray;
 };
 
-// NOTE: outArray MUST have room for all StandardPlural values.  No bounds checking is performed.
-
 /**
  * Populates outArray with `locale`-specific values for `unit` through use of
  * PluralTableSink. Only the set of basic units are supported!
@@ -174,7 +420,7 @@ class PluralTableSink : public ResourceSink {
 void getMeasureData(const Locale &locale,
                     const MeasureUnit &unit,
                     const UNumberUnitWidth &width,
-                    StringPiece unitDisplayCase,
+                    const char *unitDisplayCase,
                     UnicodeString *outArray,
                     UErrorCode &status) {
     PluralTableSink sink(outArray);
@@ -206,21 +452,26 @@ void getMeasureData(const Locale &locale,
 
     // Grab desired case first, if available. Then grab no-case data to fill in
     // the gaps.
-    if (width == UNUM_UNIT_WIDTH_FULL_NAME && !unitDisplayCase.empty()) {
+    if (width == UNUM_UNIT_WIDTH_FULL_NAME && unitDisplayCase[0] != 0) {
         CharString caseKey;
         caseKey.append(key, status);
         caseKey.append("/case/", status);
         caseKey.append(unitDisplayCase, status);
 
         UErrorCode localStatus = U_ZERO_ERROR;
+        // TODO(icu-units#138): our fallback logic is not spec-compliant:
+        // lateral fallback should happen before locale fallback. Switch to
+        // getInflectedMeasureData after homogenizing data format? Find a unit
+        // test case that demonstrates the incorrect fallback logic (via
+        // regional variant of an inflected language?)
         ures_getAllItemsWithFallback(unitsBundle.getAlias(), caseKey.data(), sink, localStatus);
-        // TODO(icu-units#138): our fallback logic is not spec-compliant: we
-        // check the given case, then go straight to the no-case data. The spec
-        // states we should first look for case="nominative". As part of #138,
-        // either get the spec changed, or add unit tests that warn us if
-        // case="nominative" data differs from no-case data?
     }
 
+    // TODO(icu-units#138): our fallback logic is not spec-compliant: we
+    // check the given case, then go straight to the no-case data. The spec
+    // states we should first look for case="nominative". As part of #138,
+    // either get the spec changed, or add unit tests that warn us if
+    // case="nominative" data differs from no-case data?
     UErrorCode localStatus = U_ZERO_ERROR;
     ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, localStatus);
     if (width == UNUM_UNIT_WIDTH_SHORT) {
@@ -240,6 +491,7 @@ void getMeasureData(const Locale &locale,
     ures_getAllItemsWithFallback(unitsBundle.getAlias(), key.data(), sink, status);
 }
 
+// NOTE: outArray MUST have a length of at least ARRAY_LENGTH.
 void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency, UnicodeString *outArray,
                              UErrorCode &status) {
     // In ICU4J, this method gets a CurrencyData from CurrencyData.provider.
@@ -268,7 +520,10 @@ void getCurrencyLongNameData(const Locale &locale, const CurrencyUnit &currency,
     }
 }
 
-UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &width, UErrorCode& status) {
+UnicodeString getCompoundValue(StringPiece compoundKey,
+                               const Locale &locale,
+                               const UNumberUnitWidth &width,
+                               UErrorCode &status) {
     LocalUResourceBundlePointer unitsBundle(ures_open(U_ICUDATA_UNIT, locale.getName(), &status));
     if (U_FAILURE(status)) { return {}; }
     CharString key;
@@ -278,9 +533,25 @@ UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &wid
     } else if (width == UNUM_UNIT_WIDTH_SHORT) {
         key.append("Short", status);
     }
-    key.append("/compound/per", status);
+    key.append("/compound/", status);
+    key.append(compoundKey, status);
+
+    UErrorCode localStatus = status;
     int32_t len = 0;
-    const UChar* ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
+    const UChar *ptr =
+        ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &localStatus);
+    if (U_FAILURE(localStatus) && width != UNUM_UNIT_WIDTH_SHORT) {
+        // Fall back to short, which contains more compound data
+        key.clear();
+        key.append("unitsShort/compound/", status);
+        key.append(compoundKey, status);
+        ptr = ures_getStringByKeyWithFallback(unitsBundle.getAlias(), key.data(), &len, &status);
+    } else {
+        status = localStatus;
+    }
+    if (U_FAILURE(status)) {
+        return {};
+    }
     return UnicodeString(ptr, len);
 }
 
@@ -293,12 +564,14 @@ UnicodeString getPerUnitFormat(const Locale& locale, const UNumberUnitWidth &wid
  *
  * Instantiating an instance as follows:
  *
- *     DerivedComponents d(loc, "case", "per", "foo");
+ *     DerivedComponents d(loc, "case", "per");
  *
- * Applying the rule in the XML element above, `d.value0()` will be "foo", and
- * `d.value1()` will be "nominative".
+ * Applying the rule in the XML element above, `d.value0("foo")` will be "foo",
+ * and `d.value1("foo")` will be "nominative".
  *
- * In case of any kind of failure, value0() and value1() will simply return "".
+ * The values returned by value0(...) and value1(...) are valid only while the
+ * instance exists. In case of any kind of failure, value0(...) and value1(...)
+ * will return "".
  */
 class DerivedComponents {
   public:
@@ -309,10 +582,7 @@ class DerivedComponents {
      * referenced by compoundValue must exist for longer than the
      * DerivedComponents instance.
      */
-    DerivedComponents(const Locale &locale,
-                      const char *feature,
-                      const char *structure,
-                      const StringPiece compoundValue) {
+    DerivedComponents(const Locale &locale, const char *feature, const char *structure) {
         StackUResourceBundle derivationsBundle, stackBundle;
         ures_openDirectFillIn(derivationsBundle.getAlias(), NULL, "grammaticalFeatures", &status);
         ures_getByKey(derivationsBundle.getAlias(), "grammaticalData", derivationsBundle.getAlias(),
@@ -323,10 +593,11 @@ class DerivedComponents {
             return;
         }
         UErrorCode localStatus = U_ZERO_ERROR;
-        // TODO: use standard normal locale resolution algorithms rather than just grabbing language:
+        // TODO(icu-units#28): use standard normal locale resolution algorithms
+        // rather than just grabbing language:
         ures_getByKey(derivationsBundle.getAlias(), locale.getLanguage(), stackBundle.getAlias(),
                       &localStatus);
-        // TODO:
+        // TODO(icu-units#28):
         // - code currently assumes if the locale exists, the rules are there -
         //   instead of falling back to root when the requested rule is missing.
         // - investigate ures.h functions, see if one that uses res_findResource()
@@ -344,38 +615,61 @@ class DerivedComponents {
         UnicodeString val1 = ures_getUnicodeStringByIndex(stackBundle.getAlias(), 1, &status);
         if (U_SUCCESS(status)) {
             if (val0.compare(UnicodeString(u"compound")) == 0) {
-                sp0 = compoundValue;
+                compound0_ = true;
             } else {
-                memory0.appendInvariantChars(val0, status);
-                sp0 = memory0.toStringPiece();
+                compound0_ = false;
+                value0_.appendInvariantChars(val0, status);
             }
             if (val1.compare(UnicodeString(u"compound")) == 0) {
-                sp1 = compoundValue;
+                compound1_ = true;
             } else {
-                memory1.appendInvariantChars(val1, status);
-                sp1 = memory1.toStringPiece();
+                compound1_ = false;
+                value1_.appendInvariantChars(val1, status);
             }
         }
     }
-    // The returned StringPiece is only valid as long as both the instance
-    // exists, and the compoundValue passed to the constructor is valid.
-    StringPiece value0() const {
-        return sp0;
+
+    // Returns a StringPiece that is only valid as long as the instance exists.
+    StringPiece value0(const StringPiece compoundValue) const {
+        return compound0_ ? compoundValue : value0_.toStringPiece();
     }
-    // The returned StringPiece is only valid as long as both the instance
-    // exists, and the compoundValue passed to the constructor is valid.
-    StringPiece value1() const {
-        return sp1;
+
+    // Returns a StringPiece that is only valid as long as the instance exists.
+    StringPiece value1(const StringPiece compoundValue) const {
+        return compound1_ ? compoundValue : value1_.toStringPiece();
+    }
+
+    // Returns a char* that is only valid as long as the instance exists.
+    const char *value0(const char *compoundValue) const {
+        return compound0_ ? compoundValue : value0_.data();
+    }
+
+    // Returns a char* that is only valid as long as the instance exists.
+    const char *value1(const char *compoundValue) const {
+        return compound1_ ? compoundValue : value1_.data();
     }
 
   private:
     UErrorCode status = U_ZERO_ERROR;
 
     // Holds strings referred to by value0 and value1;
-    CharString memory0, memory1;
-    StringPiece sp0, sp1;
+    bool compound0_, compound1_;
+    CharString value0_, value1_;
 };
 
+// TODO(icu-units#28): test somehow? Associate with an ICU ticket for adding
+// testsuite support for testing with synthetic data?
+/**
+ * Loads and returns the value in rules that look like these:
+ *
+ * <deriveCompound feature="gender" structure="per" value="0"/>
+ * <deriveCompound feature="gender" structure="times" value="1"/>
+ *
+ * Currently a fake example, but spec compliant:
+ * <deriveCompound feature="gender" structure="power" value="feminine"/>
+ *
+ * NOTE: If U_FAILURE(status), returns an empty string.
+ */ 
 UnicodeString
 getDeriveCompoundRule(Locale locale, const char *feature, const char *structure, UErrorCode &status) {
     StackUResourceBundle derivationsBundle, stackBundle;
@@ -397,7 +691,45 @@ getDeriveCompoundRule(Locale locale, const char *feature, const char *structure,
     }
     ures_getByKey(stackBundle.getAlias(), "compound", stackBundle.getAlias(), &status);
     ures_getByKey(stackBundle.getAlias(), feature, stackBundle.getAlias(), &status);
-    return ures_getUnicodeStringByKey(stackBundle.getAlias(), structure, &status);
+    UnicodeString uVal = ures_getUnicodeStringByKey(stackBundle.getAlias(), structure, &status);
+    if (U_FAILURE(status)) {
+        return {};
+    }
+    U_ASSERT(!uVal.isBogus());
+    return uVal;
+}
+
+// Returns the gender string for structures following these rules:
+//
+// <deriveCompound feature="gender" structure="per" value="0"/>
+// <deriveCompound feature="gender" structure="times" value="1"/>
+//
+// Fake example:
+// <deriveCompound feature="gender" structure="power" value="feminine"/>
+//
+// data0 and data1 should be pattern arrays (UnicodeString[ARRAY_SIZE]) that
+// correspond to value="0" and value="1".
+//
+// Pass a nullptr to data1 if the structure has no concept of value="1" (e.g.
+// "prefix" doesn't).
+UnicodeString getDerivedGender(Locale locale,
+                               const char *structure,
+                               UnicodeString *data0,
+                               UnicodeString *data1,
+                               UErrorCode &status) {
+    UnicodeString val = getDeriveCompoundRule(locale, "gender", structure, status);
+    if (val.length() == 1) {
+        switch (val[0]) {
+        case u'0':
+            return data0[GENDER_INDEX];
+        case u'1':
+            if (data1 == nullptr) {
+                return {};
+            }
+            return data1[GENDER_INDEX];
+        }
+    }
+    return val;
 }
 
 ////////////////////////
@@ -430,27 +762,84 @@ const UChar *trimSpaceChars(const UChar *s, int32_t &length) {
 void LongNameHandler::forMeasureUnit(const Locale &loc,
                                      const MeasureUnit &unitRef,
                                      const UNumberUnitWidth &width,
-                                     StringPiece unitDisplayCase,
+                                     const char *unitDisplayCase,
                                      const PluralRules *rules,
                                      const MicroPropsGenerator *parent,
                                      LongNameHandler *fillIn,
                                      UErrorCode &status) {
-    // Not valid for mixed units that aren't built-in units, and there should
-    // not be any built-in mixed units!
+    // From https://unicode.org/reports/tr35/tr35-general.html#compound-units -
+    // Points 1 and 2 are mostly handled by MeasureUnit:
+    //
+    // 1. If the unitId is empty or invalid, fail
+    // 2. Put the unitId into normalized order
+    //
+    // We just need to check if it is a MeasureUnit this constructor handles:
+    // this constructor does not handle mixed units
     U_ASSERT(uprv_strcmp(unitRef.getType(), "") != 0 ||
              unitRef.getComplexity(status) != UMEASURE_UNIT_MIXED);
     U_ASSERT(fillIn != nullptr);
 
-    if (uprv_strcmp(unitRef.getType(), "") == 0) {
-        // Not a built-in unit. Split it up, since we can already format
-        // "builtin-per-builtin".
-        // TODO(ICU-20941): support more generic case than builtin-per-builtin.
+    if (uprv_strcmp(unitRef.getType(), "") != 0) {
+        // Handling built-in units:
+        //
+        // 3. Set result to be getValue(unitId with length, pluralCategory, caseVariant)
+        //    - If result is not empty, return it
+        UnicodeString simpleFormats[ARRAY_LENGTH];
+        getMeasureData(loc, unitRef, width, unitDisplayCase, simpleFormats, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        fillIn->rules = rules;
+        fillIn->parent = parent;
+        fillIn->simpleFormatsToModifiers(simpleFormats,
+                                         {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
+        if (!simpleFormats[GENDER_INDEX].isBogus()) {
+            fillIn->gender = getGenderString(simpleFormats[GENDER_INDEX], status);
+        }
+        return;
+
+        // TODO(icu-units#145): figure out why this causes a failure in
+        // format/MeasureFormatTest/TestIndividualPluralFallback and other
+        // tests, when it should have been an alternative for the lines above:
+
+        // forArbitraryUnit(loc, unitRef, width, unitDisplayCase, fillIn, status);
+        // fillIn->rules = rules;
+        // fillIn->parent = parent;
+        // return;
+    } else {
+        forArbitraryUnit(loc, unitRef, width, unitDisplayCase, fillIn, status);
+        fillIn->rules = rules;
+        fillIn->parent = parent;
+        return;
+    }
+}
+
+void LongNameHandler::forArbitraryUnit(const Locale &loc,
+                                       const MeasureUnit &unitRef,
+                                       const UNumberUnitWidth &width,
+                                       const char *unitDisplayCase,
+                                       LongNameHandler *fillIn,
+                                       UErrorCode &status) {
+    if (U_FAILURE(status)) {
+        return;
+    }
+    if (fillIn == nullptr) {
+        status = U_INTERNAL_PROGRAM_ERROR;
+        return;
+    }
+
+    // Numbered list items are from the algorithms at
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units:
+    //
+    // 4. Divide the unitId into numerator (the part before the "-per-") and
+    //    denominator (the part after the "-per-). If both are empty, fail
+    MeasureUnitImpl unit;
+    MeasureUnitImpl perUnit;
+    {
         MeasureUnitImpl fullUnit = MeasureUnitImpl::forMeasureUnitMaybeCopy(unitRef, status);
         if (U_FAILURE(status)) {
             return;
         }
-        MeasureUnitImpl unit;
-        MeasureUnitImpl perUnit;
         for (int32_t i = 0; i < fullUnit.singleUnits.length(); i++) {
             SingleUnitImpl *subUnit = fullUnit.singleUnits[i];
             if (subUnit->dimensionality > 0) {
@@ -460,120 +849,454 @@ void LongNameHandler::forMeasureUnit(const Locale &loc,
                 perUnit.appendSingleUnit(*subUnit, status);
             }
         }
-        forCompoundUnit(loc, std::move(unit).build(status), std::move(perUnit).build(status), width,
-                        unitDisplayCase, rules, parent, fillIn, status);
-        return;
     }
 
-    UnicodeString simpleFormats[ARRAY_LENGTH];
-    getMeasureData(loc, unitRef, width, unitDisplayCase, simpleFormats, status);
-    if (U_FAILURE(status)) {
-        return;
+    // TODO(icu-units#28): check placeholder logic, see if it needs to be
+    // present here instead of only in processPatternTimes:
+    //
+    // 5. Set both globalPlaceholder and globalPlaceholderPosition to be empty
+
+    DerivedComponents derivedPerCases(loc, "case", "per");
+
+    // 6. numeratorUnitString
+    UnicodeString numeratorUnitData[ARRAY_LENGTH];
+    processPatternTimes(std::move(unit), loc, width, derivedPerCases.value0(unitDisplayCase),
+                        numeratorUnitData, status);
+
+    // 7. denominatorUnitString
+    UnicodeString denominatorUnitData[ARRAY_LENGTH];
+    processPatternTimes(std::move(perUnit), loc, width, derivedPerCases.value1(unitDisplayCase),
+                        denominatorUnitData, status);
+
+    // TODO(icu-units#139):
+    // - implement DerivedComponents for "plural/times" and "plural/power":
+    //   French has different rules, we'll be producing the wrong results
+    //   currently. (Prove via tests!)
+    // - implement DerivedComponents for "plural/per", "plural/prefix",
+    //   "case/times", "case/power", and "case/prefix" - although they're
+    //   currently hardcoded. Languages with different rules are surely on the
+    //   way.
+    //
+    // Currently we only use "case/per", "plural/times", "case/times", and
+    // "case/power".
+    //
+    // This may have impact on multiSimpleFormatsToModifiers(...) below too?
+    // These rules are currently (ICU 69) all the same and hard-coded below.
+    UnicodeString perUnitPattern;
+    if (!denominatorUnitData[PER_INDEX].isBogus()) {
+        // If we have no denominator, we obtain the empty string:
+        perUnitPattern = denominatorUnitData[PER_INDEX];
+    } else {
+        // 8. Set perPattern to be getValue([per], locale, length)
+        UnicodeString rawPerUnitFormat = getCompoundValue("per", loc, width, status);
+        // rawPerUnitFormat is something like "{0} per {1}"; we need to substitute in the secondary unit.
+        SimpleFormatter perPatternFormatter(rawPerUnitFormat, 2, 2, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        // Plural and placeholder handling for 7. denominatorUnitString:
+        // TODO(icu-units#139): hardcoded:
+        // <deriveComponent feature="plural" structure="per" value0="compound" value1="one"/>
+        UnicodeString denominatorFormat =
+            getWithPlural(denominatorUnitData, StandardPlural::Form::ONE, status);
+        // Some "one" pattern may not contain "{0}". For example in "ar" or "ne" locale.
+        SimpleFormatter denominatorFormatter(denominatorFormat, 0, 1, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
+        UnicodeString denominatorPattern = denominatorFormatter.getTextWithNoArguments();
+        int32_t trimmedLen = denominatorPattern.length();
+        const UChar *trimmed = trimSpaceChars(denominatorPattern.getBuffer(), trimmedLen);
+        UnicodeString denominatorString(false, trimmed, trimmedLen);
+        // 9. If the denominatorString is empty, set result to
+        //    [numeratorString], otherwise set result to format(perPattern,
+        //    numeratorString, denominatorString)
+        //
+        // TODO(icu-units#28): Why does UnicodeString need to be explicit in the
+        // following line?
+        perPatternFormatter.format(UnicodeString(u"{0}"), denominatorString, perUnitPattern, status);
+        if (U_FAILURE(status)) {
+            return;
+        }
     }
-    fillIn->rules = rules;
-    fillIn->parent = parent;
-    fillIn->simpleFormatsToModifiers(simpleFormats, {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD},
-                                     status);
-    if (!simpleFormats[GENDER_INDEX].isBogus()) {
-        fillIn->gender = getGenderString(simpleFormats[GENDER_INDEX], status);
+    if (perUnitPattern.length() == 0) {
+        fillIn->simpleFormatsToModifiers(numeratorUnitData,
+                                         {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
+    } else {
+        fillIn->multiSimpleFormatsToModifiers(numeratorUnitData, perUnitPattern,
+                                              {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
     }
+
+    // Gender
+    //
+    // TODO(icu-units#28): find out what gender to use in the absence of a first
+    // value - e.g. what's the gender of "per-second"? Mentioned in CLDR-14253.
+    //
+    // gender/per deriveCompound rules don't say:
+    // <deriveCompound feature="gender" structure="per" value="0"/> <!-- gender(gram-per-meter) ←  gender(gram) -->
+    fillIn->gender = getGenderString(
+        getDerivedGender(loc, "per", numeratorUnitData, denominatorUnitData, status), status);
 }
 
-void LongNameHandler::forCompoundUnit(const Locale &loc,
-                                      const MeasureUnit &unit,
-                                      const MeasureUnit &perUnit,
-                                      const UNumberUnitWidth &width,
-                                      StringPiece unitDisplayCase,
-                                      const PluralRules *rules,
-                                      const MicroPropsGenerator *parent,
-                                      LongNameHandler *fillIn,
-                                      UErrorCode &status) {
+void LongNameHandler::processPatternTimes(MeasureUnitImpl &&productUnit,
+                                          Locale loc,
+                                          const UNumberUnitWidth &width,
+                                          const char *caseVariant,
+                                          UnicodeString *outArray,
+                                          UErrorCode &status) {
     if (U_FAILURE(status)) {
         return;
     }
-    if (uprv_strcmp(unit.getType(), "") == 0 || uprv_strcmp(perUnit.getType(), "") == 0) {
-        // TODO(ICU-20941): Unsanctioned unit. Not yet fully supported. Set an
-        // error code. Once we support not-built-in units here, unitRef may be
-        // anything, but if not built-in, perUnit has to be "none".
+    if (productUnit.complexity == UMEASURE_UNIT_MIXED) {
+        // These are handled by MixedUnitLongNameHandler
         status = U_UNSUPPORTED_ERROR;
         return;
     }
-    if (fillIn == nullptr) {
-        status = U_INTERNAL_PROGRAM_ERROR;
-        return;
+
+#if U_DEBUG
+    for (int32_t pluralIndex = 0; pluralIndex < ARRAY_LENGTH; pluralIndex++) {
+        U_ASSERT(outArray[pluralIndex].length() == 0);
+        U_ASSERT(!outArray[pluralIndex].isBogus());
     }
+#endif
 
-    DerivedComponents derivedPerCases(loc, "case", "per", unitDisplayCase);
-
-    UnicodeString primaryData[ARRAY_LENGTH];
-    getMeasureData(loc, unit, width, derivedPerCases.value0(), primaryData, status);
+    if (productUnit.identifier.isEmpty()) {
+        // TODO(icu-units#28): consider when serialize should be called.
+        // identifier might also be empty for MeasureUnit().
+        productUnit.serialize(status);
+    }
     if (U_FAILURE(status)) {
         return;
     }
-    UnicodeString secondaryData[ARRAY_LENGTH];
-    getMeasureData(loc, perUnit, width, derivedPerCases.value1(), secondaryData, status);
+    if (productUnit.identifier.length() == 0) {
+        // MeasureUnit(): no units: return empty strings.
+        return;
+    }
+
+    MeasureUnit builtinUnit;
+    if (MeasureUnit::findBySubType(productUnit.identifier.toStringPiece(), &builtinUnit)) {
+        // TODO(icu-units#145): spec doesn't cover builtin-per-builtin, it
+        // breaks them all down. Do we want to drop this?
+        // - findBySubType isn't super efficient, if we skip it and go to basic
+        //   singles, we don't have to construct MeasureUnit's anymore.
+        // - Check all the existing unit tests that fail without this: is it due
+        //   to incorrect fallback via getMeasureData?
+        // - Do those unit tests cover this code path representatively?
+        if (builtinUnit != MeasureUnit()) {
+            getMeasureData(loc, builtinUnit, width, caseVariant, outArray, status);
+        }
+        return;
+    }
+
+    // 2. Set timesPattern to be getValue(times, locale, length)
+    UnicodeString timesPattern = getCompoundValue("times", loc, width, status);
+    SimpleFormatter timesPatternFormatter(timesPattern, 2, 2, status);
     if (U_FAILURE(status)) {
         return;
     }
 
-    // TODO(icu-units#139): implement these rules:
-    // <deriveComponent feature="plural" structure="per" ...>
-    // This has impact on multiSimpleFormatsToModifiers(...) below too.
-    // These rules are currently (ICU 69) all the same and hard-coded below.
-    UnicodeString perUnitFormat;
-    if (!secondaryData[PER_INDEX].isBogus()) {
-        perUnitFormat = secondaryData[PER_INDEX];
-    } else {
-        UnicodeString rawPerUnitFormat = getPerUnitFormat(loc, width, status);
-        if (U_FAILURE(status)) {
-            return;
+    PlaceholderPosition globalPlaceholder[ARRAY_LENGTH];
+    UChar globalJoinerChar = 0;
+    // Numbered list items are from the algorithms at
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units:
+    //
+    // pattern(...) point 5:
+    // - Set both globalPlaceholder and globalPlaceholderPosition to be empty
+    //
+    // 3. Set result to be empty
+    for (int32_t pluralIndex = 0; pluralIndex < ARRAY_LENGTH; pluralIndex++) {
+        // Initial state: empty string pattern, via all falling back to OTHER:
+        if (pluralIndex == StandardPlural::Form::OTHER) {
+            outArray[pluralIndex].remove();
+        } else {
+            outArray[pluralIndex].setToBogus();
         }
-        // rawPerUnitFormat is something like "{0} per {1}"; we need to substitute in the secondary unit.
-        SimpleFormatter compiled(rawPerUnitFormat, 2, 2, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-        UnicodeString secondaryFormat = getWithPlural(secondaryData, StandardPlural::Form::ONE, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-        // Some "one" pattern may not contain "{0}". For example in "ar" or "ne" locale.
-        SimpleFormatter secondaryCompiled(secondaryFormat, 0, 1, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
-        UnicodeString secondaryFormatString = secondaryCompiled.getTextWithNoArguments();
-        int32_t trimmedSecondaryLen = secondaryFormatString.length();
-        const UChar *trimmedSecondaryString =
-            trimSpaceChars(secondaryFormatString.getBuffer(), trimmedSecondaryLen);
-        UnicodeString secondaryString(false, trimmedSecondaryString, trimmedSecondaryLen);
-        // TODO: Why does UnicodeString need to be explicit in the following line?
-        compiled.format(UnicodeString(u"{0}"), secondaryString, perUnitFormat, status);
-        if (U_FAILURE(status)) {
-            return;
-        }
+        globalPlaceholder[pluralIndex] = PH_EMPTY;
     }
-    fillIn->rules = rules;
-    fillIn->parent = parent;
-    fillIn->multiSimpleFormatsToModifiers(primaryData, perUnitFormat,
-                                          {UFIELD_CATEGORY_NUMBER, UNUM_MEASURE_UNIT_FIELD}, status);
 
-    // Gender
-    UnicodeString uVal = getDeriveCompoundRule(loc, "gender", "per", status);
-    if (U_FAILURE(status)) {
-        return;
+    // Empty string represents "compound" (propagate the plural form).
+    const char *pluralCategory = "";
+    DerivedComponents derivedTimesPlurals(loc, "plural", "times");
+    DerivedComponents derivedTimesCases(loc, "case", "times");
+    DerivedComponents derivedPowerCases(loc, "case", "power");
+
+    // 4. For each single_unit in product_unit
+    for (int32_t singleUnitIndex = 0; singleUnitIndex < productUnit.singleUnits.length();
+         singleUnitIndex++) {
+        SingleUnitImpl *singleUnit = productUnit.singleUnits[singleUnitIndex];
+        const char *singlePluralCategory;
+        const char *singleCaseVariant;
+        // TODO(icu-units#28): ensure we have unit tests that change/fail if we
+        // assign incorrect case variants here:
+        if (singleUnitIndex < productUnit.singleUnits.length() - 1) {
+            // 4.1. If hasMultiple
+            singlePluralCategory = derivedTimesPlurals.value0(pluralCategory);
+            singleCaseVariant = derivedTimesCases.value0(caseVariant);
+            pluralCategory = derivedTimesPlurals.value1(pluralCategory);
+            caseVariant = derivedTimesCases.value1(caseVariant);
+        } else {
+            singlePluralCategory = derivedTimesPlurals.value1(pluralCategory);
+            singleCaseVariant = derivedTimesCases.value1(caseVariant);
+        }
+
+        // 4.2. Get the gender of that single_unit
+        MeasureUnit builtinUnit;
+        if (!MeasureUnit::findBySubType(singleUnit->getSimpleUnitID(), &builtinUnit)) {
+            // Ideally all simple units should be known, but they're not:
+            // 100-kilometer is internally treated as a simple unit, but it is
+            // not a built-in unit and does not have formatting data in CLDR 39.
+            //
+            // TODO(icu-units#28): test (desirable) invariants in unit tests.
+            status = U_UNSUPPORTED_ERROR;
+            return;
+        }
+        const char *gender = getGenderForBuiltin(loc, builtinUnit, status);
+
+        // 4.3. If singleUnit starts with a dimensionality_prefix, such as 'square-'
+        U_ASSERT(singleUnit->dimensionality > 0);
+        int32_t dimensionality = singleUnit->dimensionality;
+        UnicodeString dimensionalityPrefixPatterns[ARRAY_LENGTH];
+        if (dimensionality != 1) {
+            // 4.3.1. set dimensionalityPrefixPattern to be
+            //   getValue(that dimensionality_prefix, locale, length, singlePluralCategory, singleCaseVariant, gender),
+            //   such as "{0} kwadratowym"
+            CharString dimensionalityKey("compound/power", status);
+            dimensionalityKey.appendNumber(dimensionality, status);
+            getInflectedMeasureData(dimensionalityKey.toStringPiece(), loc, width, gender,
+                                    singleCaseVariant, dimensionalityPrefixPatterns, status);
+            if (U_FAILURE(status)) {
+                // At the time of writing, only power2 and power3 are supported.
+                // Attempting to format other powers results in a
+                // U_RESOURCE_TYPE_MISMATCH. We convert the error if we
+                // understand it:
+                if (status == U_RESOURCE_TYPE_MISMATCH && dimensionality > 3) {
+                    status = U_UNSUPPORTED_ERROR;
+                }
+                return;
+            }
+
+            // TODO(icu-units#139):
+            // 4.3.2. set singlePluralCategory to be power0(singlePluralCategory)
+
+            // 4.3.3. set singleCaseVariant to be power0(singleCaseVariant)
+            singleCaseVariant = derivedPowerCases.value0(singleCaseVariant);
+            // 4.3.4. remove the dimensionality_prefix from singleUnit
+            singleUnit->dimensionality = 1;
+        }
+
+        // 4.4. if singleUnit starts with an si_prefix, such as 'centi'
+        UMeasurePrefix prefix = singleUnit->unitPrefix;
+        UnicodeString prefixPattern;
+        if (prefix != UMEASURE_PREFIX_ONE) {
+            // 4.4.1. set siPrefixPattern to be getValue(that si_prefix, locale,
+            //        length), such as "centy{0}"
+            CharString prefixKey;
+            // prefixKey looks like "1024p3" or "10p-2":
+            prefixKey.appendNumber(umeas_getPrefixBase(prefix), status);
+            prefixKey.append('p', status);
+            prefixKey.appendNumber(umeas_getPrefixPower(prefix), status);
+            // Contains a pattern like "centy{0}".
+            prefixPattern = getCompoundValue(prefixKey.toStringPiece(), loc, width, status);
+
+            // 4.4.2. set singlePluralCategory to be prefix0(singlePluralCategory)
+            //
+            // TODO(icu-units#139): that refers to these rules:
+            // <deriveComponent feature="plural" structure="prefix" value0="one" value1="compound"/>
+            // though I'm not sure what other value they might end up having.
+            //
+            // 4.4.3. set singleCaseVariant to be prefix0(singleCaseVariant)
+            //
+            // TODO(icu-units#139): that refers to:
+            // <deriveComponent feature="case" structure="prefix" value0="nominative"
+            // value1="compound"/> but the prefix (value0) doesn't have case, the rest simply
+            // propagates.
+
+            // 4.4.4. remove the si_prefix from singleUnit
+            singleUnit->unitPrefix = UMEASURE_PREFIX_ONE;
+        }
+
+        // 4.5. Set corePattern to be the getValue(singleUnit, locale, length,
+        //      singlePluralCategory, singleCaseVariant), such as "{0} metrem"
+        UnicodeString singleUnitArray[ARRAY_LENGTH];
+        // At this point we are left with a Simple Unit:
+        U_ASSERT(uprv_strcmp(singleUnit->build(status).getIdentifier(), singleUnit->getSimpleUnitID()) ==
+                 0);
+        getMeasureData(loc, singleUnit->build(status), width, singleCaseVariant, singleUnitArray,
+                       status);
+        if (U_FAILURE(status)) {
+            // Shouldn't happen if we have data for all single units
+            return;
+        }
+
+        // Calculate output gender
+        if (!singleUnitArray[GENDER_INDEX].isBogus()) {
+            U_ASSERT(!singleUnitArray[GENDER_INDEX].isEmpty());
+            UnicodeString uVal;
+
+            if (prefix != UMEASURE_PREFIX_ONE) {
+                singleUnitArray[GENDER_INDEX] =
+                    getDerivedGender(loc, "prefix", singleUnitArray, nullptr, status);
+            }
+
+            // Powers use compoundUnitPattern1, dimensionalityPrefixPatterns may
+            // have a "gender" element
+            //
+            // TODO(icu-units#28): untested: no locale data uses this currently:
+            if (dimensionality != 1) {
+                singleUnitArray[GENDER_INDEX] = getDerivedGender(loc, "power", singleUnitArray,
+                                                                 dimensionalityPrefixPatterns, status);
+            }
+
+            UnicodeString timesGenderRule = getDeriveCompoundRule(loc, "gender", "times", status);
+            if (timesGenderRule.length() == 1) {
+                switch (timesGenderRule[0]) {
+                case u'0':
+                    if (singleUnitIndex == 0) {
+                        U_ASSERT(outArray[GENDER_INDEX].isBogus());
+                        outArray[GENDER_INDEX] = singleUnitArray[GENDER_INDEX];
+                    }
+                    break;
+                case u'1':
+                    if (singleUnitIndex == productUnit.singleUnits.length() - 1) {
+                        U_ASSERT(outArray[GENDER_INDEX].isBogus());
+                        outArray[GENDER_INDEX] = singleUnitArray[GENDER_INDEX];
+                    }
+                }
+            } else {
+                if (outArray[GENDER_INDEX].isBogus()) {
+                    outArray[GENDER_INDEX] = timesGenderRule;
+                }
+            }
+        }
+
+        // Calculate resulting patterns for each plural form
+        for (int32_t pluralIndex = 0; pluralIndex < StandardPlural::Form::COUNT; pluralIndex++) {
+            StandardPlural::Form plural = static_cast<StandardPlural::Form>(pluralIndex);
+
+            // singleUnitArray[pluralIndex] looks something like "{0} Meter"
+            if (outArray[pluralIndex].isBogus()) {
+                if (singleUnitArray[pluralIndex].isBogus()) {
+                    // Let the usual plural fallback mechanism take care of this
+                    // plural form
+                    continue;
+                } else {
+                    // Since our singleUnit can have a plural form that outArray
+                    // doesn't yet have (relying on fallback to OTHER), we start
+                    // by grabbing it with the normal plural fallback mechanism
+                    outArray[pluralIndex] = getWithPlural(outArray, plural, status);
+                    if (U_FAILURE(status)) {
+                        return;
+                    }
+                }
+            }
+
+            if (uprv_strcmp(singlePluralCategory, "") != 0) {
+                plural = static_cast<StandardPlural::Form>(getIndex(singlePluralCategory, status));
+            }
+
+            // 4.6. Extract(corePattern, coreUnit, placeholder, placeholderPosition) from that pattern.
+            UnicodeString coreUnit;
+            PlaceholderPosition placeholderPosition;
+            UChar joinerChar;
+            extractCorePattern(getWithPlural(singleUnitArray, plural, status), coreUnit,
+                               placeholderPosition, joinerChar);
+
+            // 4.7 If the position is middle, then fail
+            if (placeholderPosition == PH_MIDDLE) {
+                status = U_UNSUPPORTED_ERROR;
+                return;
+            }
+
+            // 4.8. If globalPlaceholder is empty
+            if (globalPlaceholder[pluralIndex] == PH_EMPTY) {
+                globalPlaceholder[pluralIndex] = placeholderPosition;
+                globalJoinerChar = joinerChar;
+            } else {
+                // Expect all units involved to have the same placeholder position
+                U_ASSERT(globalPlaceholder[pluralIndex] == placeholderPosition);
+                // TODO(icu-units#28): Do we want to add a unit test that checks
+                // for consistent joiner chars? Probably not, given how
+                // inconsistent they are. File a CLDR ticket with examples?
+            }
+            // Now coreUnit would be just "Meter"
+
+            // 4.9. If siPrefixPattern is not empty
+            if (prefix != UMEASURE_PREFIX_ONE) {
+                SimpleFormatter prefixCompiled(prefixPattern, 1, 1, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+
+                // 4.9.1. Set coreUnit to be the combineLowercasing(locale, length, siPrefixPattern,
+                //        coreUnit)
+                UnicodeString tmp;
+                // combineLowercasing(locale, length, prefixPattern, coreUnit)
+                //
+                // TODO(icu-units#28): run this only if prefixPattern does not
+                // contain space characters - do languages "as", "bn", "hi",
+                // "kk", etc have concepts of upper and lower case?:
+                if (width == UNUM_UNIT_WIDTH_FULL_NAME) {
+                    coreUnit.toLower(loc);
+                }
+                prefixCompiled.format(coreUnit, tmp, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+                coreUnit = tmp;
+            }
+
+            // 4.10. If dimensionalityPrefixPattern is not empty
+            if (dimensionality != 1) {
+                SimpleFormatter dimensionalityCompiled(
+                    getWithPlural(dimensionalityPrefixPatterns, plural, status), 1, 1, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+
+                // 4.10.1. Set coreUnit to be the combineLowercasing(locale, length,
+                //         dimensionalityPrefixPattern, coreUnit)
+                UnicodeString tmp;
+                // combineLowercasing(locale, length, prefixPattern, coreUnit)
+                //
+                // TODO(icu-units#28): run this only if prefixPattern does not
+                // contain space characters - do languages "as", "bn", "hi",
+                // "kk", etc have concepts of upper and lower case?:
+                if (width == UNUM_UNIT_WIDTH_FULL_NAME) {
+                    coreUnit.toLower(loc);
+                }
+                dimensionalityCompiled.format(coreUnit, tmp, status);
+                if (U_FAILURE(status)) {
+                    return;
+                }
+                coreUnit = tmp;
+            }
+
+            if (outArray[pluralIndex].length() == 0) {
+                // 4.11. If the result is empty, set result to be coreUnit
+                outArray[pluralIndex] = coreUnit;
+            } else {
+                // 4.12. Otherwise set result to be format(timesPattern, result, coreUnit)
+                UnicodeString tmp;
+                timesPatternFormatter.format(outArray[pluralIndex], coreUnit, tmp, status);
+                outArray[pluralIndex] = tmp;
+            }
+        }
     }
-    U_ASSERT(!uVal.isBogus() && uVal.length() == 1);
-    switch (uVal[0]) {
-    case u'0':
-        fillIn->gender = getGenderString(primaryData[GENDER_INDEX], status);
-        break;
-    case u'1':
-        fillIn->gender = getGenderString(secondaryData[GENDER_INDEX], status);
-        break;
-    default:
-        // Data error. Assert-fail in debug mode, else return no gender.
-        U_ASSERT(false);
+    for (int32_t pluralIndex = 0; pluralIndex < StandardPlural::Form::COUNT; pluralIndex++) {
+        if (globalPlaceholder[pluralIndex] == PH_BEGINNING) {
+            UnicodeString tmp;
+            tmp.append(u"{0}", 3);
+            if (globalJoinerChar != 0) {
+                tmp.append(globalJoinerChar);
+            }
+            tmp.append(outArray[pluralIndex]);
+            outArray[pluralIndex] = tmp;
+        } else if (globalPlaceholder[pluralIndex] == PH_END) {
+            if (globalJoinerChar != 0) {
+                outArray[pluralIndex].append(globalJoinerChar);
+            }
+            outArray[pluralIndex].append(u"{0}", 3);
+        }
     }
 }
 
@@ -623,7 +1346,7 @@ LongNameHandler* LongNameHandler::forCurrencyLongNames(const Locale &loc, const
     getCurrencyLongNameData(loc, currency, simpleFormats, status);
     if (U_FAILURE(status)) { return nullptr; }
     result->simpleFormatsToModifiers(simpleFormats, {UFIELD_CATEGORY_NUMBER, UNUM_CURRENCY_FIELD}, status);
-    // TODO(inflections): currency gender?
+    // TODO(icu-units#28): currency gender?
     return result;
 }
 
@@ -648,8 +1371,12 @@ void LongNameHandler::multiSimpleFormatsToModifiers(const UnicodeString *leadFor
         UnicodeString leadFormat = getWithPlural(leadFormats, plural, status);
         if (U_FAILURE(status)) { return; }
         UnicodeString compoundFormat;
-        trailCompiled.format(leadFormat, compoundFormat, status);
-        if (U_FAILURE(status)) { return; }
+        if (leadFormat.length() == 0) {
+            compoundFormat = trailFormat;
+        } else {
+            trailCompiled.format(leadFormat, compoundFormat, status);
+            if (U_FAILURE(status)) { return; }
+        }
         SimpleFormatter compoundCompiled(compoundFormat, 0, 1, status);
         if (U_FAILURE(status)) { return; }
         fModifiers[i] = SimpleModifier(compoundCompiled, field, false, {this, SIGNUM_POS_ZERO, plural});
@@ -673,16 +1400,24 @@ const Modifier* LongNameHandler::getModifier(Signum /*signum*/, StandardPlural::
 void MixedUnitLongNameHandler::forMeasureUnit(const Locale &loc,
                                               const MeasureUnit &mixedUnit,
                                               const UNumberUnitWidth &width,
-                                              StringPiece unitDisplayCase,
+                                              const char *unitDisplayCase,
                                               const PluralRules *rules,
                                               const MicroPropsGenerator *parent,
                                               MixedUnitLongNameHandler *fillIn,
                                               UErrorCode &status) {
-    U_ASSERT(mixedUnit.getComplexity(status) == UMEASURE_UNIT_MIXED);
     U_ASSERT(fillIn != nullptr);
+    if (U_FAILURE(status)) {
+        return;
+    }
 
     MeasureUnitImpl temp;
     const MeasureUnitImpl &impl = MeasureUnitImpl::forMeasureUnit(mixedUnit, temp, status);
+    if (impl.complexity != UMEASURE_UNIT_MIXED) {
+        // Should be using the normal LongNameHandler
+        status = U_UNSUPPORTED_ERROR;
+        return;
+    }
+
     fillIn->fMixedUnitCount = impl.singleUnits.length();
     fillIn->fMixedUnitData.adoptInstead(new UnicodeString[fillIn->fMixedUnitCount * ARRAY_LENGTH]);
     for (int32_t i = 0; i < fillIn->fMixedUnitCount; i++) {
@@ -814,7 +1549,7 @@ const Modifier *MixedUnitLongNameHandler::getMixedUnitModifier(DecimalQuantity &
 
 const Modifier *MixedUnitLongNameHandler::getModifier(Signum /*signum*/,
                                                       StandardPlural::Form /*plural*/) const {
-    // TODO(units): investigate this method when investigating where
+    // TODO(icu-units#28): investigate this method when investigating where
     // ModifierStore::getModifier() gets used. To be sure it remains
     // unreachable:
     UPRV_UNREACHABLE;
@@ -824,7 +1559,7 @@ const Modifier *MixedUnitLongNameHandler::getModifier(Signum /*signum*/,
 LongNameMultiplexer *LongNameMultiplexer::forMeasureUnits(const Locale &loc,
                                                           const MaybeStackVector<MeasureUnit> &units,
                                                           const UNumberUnitWidth &width,
-                                                          StringPiece unitDisplayCase,
+                                                          const char *unitDisplayCase,
                                                           const PluralRules *rules,
                                                           const MicroPropsGenerator *parent,
                                                           UErrorCode &status) {
diff --git a/icu4c/source/i18n/number_longnames.h b/icu4c/source/i18n/number_longnames.h
index 8b004f0..cc66aff 100644
--- a/icu4c/source/i18n/number_longnames.h
+++ b/icu4c/source/i18n/number_longnames.h
@@ -62,7 +62,7 @@ class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public
     static void forMeasureUnit(const Locale &loc,
                                const MeasureUnit &unitRef,
                                const UNumberUnitWidth &width,
-                               StringPiece unitDisplayCase,
+                               const char *unitDisplayCase,
                                const PluralRules *rules,
                                const MicroPropsGenerator *parent,
                                LongNameHandler *fillIn,
@@ -102,18 +102,25 @@ class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public
     // Allow macrosToMicroGenerator to call the private default constructor.
     friend class NumberFormatterImpl;
 
-    // Fills in LongNameHandler fields for formatting compound units identified
-    // via `unit` and `perUnit`. Both `unit` and `perUnit` need to be built-in
-    // units (for which data exists).
-    static void forCompoundUnit(const Locale &loc,
-                                const MeasureUnit &unit,
-                                const MeasureUnit &perUnit,
-                                const UNumberUnitWidth &width,
-                                StringPiece unitDisplayCase,
-                                const PluralRules *rules,
-                                const MicroPropsGenerator *parent,
-                                LongNameHandler *fillIn,
-                                UErrorCode &status);
+    // Fills in LongNameHandler fields for formatting units identified `unit`.
+    static void forArbitraryUnit(const Locale &loc,
+                                 const MeasureUnit &unit,
+                                 const UNumberUnitWidth &width,
+                                 const char *unitDisplayCase,
+                                 LongNameHandler *fillIn,
+                                 UErrorCode &status);
+
+    // Roughly corresponds to patternTimes(...) in the spec:
+    // https://unicode.org/reports/tr35/tr35-general.html#compound-units
+    //
+    // productUnit is an rvalue reference to indicate this function consumes it,
+    // leaving it in a not-useful / undefined state.
+    static void processPatternTimes(MeasureUnitImpl &&productUnit,
+                                    Locale loc,
+                                    const UNumberUnitWidth &width,
+                                    const char *caseVariant,
+                                    UnicodeString *outArray,
+                                    UErrorCode &status);
 
     // Sets fModifiers to use the patterns from `simpleFormats`.
     void simpleFormatsToModifiers(const UnicodeString *simpleFormats, Field field, UErrorCode &status);
@@ -122,7 +129,7 @@ class LongNameHandler : public MicroPropsGenerator, public ModifierStore, public
     // and `trailFormat` appended to each.
     //
     // With a leadFormat of "{0}m" and a trailFormat of "{0}/s", it produces a
-    // pattern of "{0}m/s" by inserting the leadFormat pattern into trailFormat.
+    // pattern of "{0}m/s" by inserting each leadFormat pattern into trailFormat.
     void multiSimpleFormatsToModifiers(const UnicodeString *leadFormats, UnicodeString trailFormat,
                                        Field field, UErrorCode &status);
 };
@@ -153,7 +160,7 @@ class MixedUnitLongNameHandler : public MicroPropsGenerator, public ModifierStor
     static void forMeasureUnit(const Locale &loc,
                                const MeasureUnit &mixedUnit,
                                const UNumberUnitWidth &width,
-                               StringPiece unitDisplayCase,
+                               const char *unitDisplayCase,
                                const PluralRules *rules,
                                const MicroPropsGenerator *parent,
                                MixedUnitLongNameHandler *fillIn,
@@ -230,7 +237,7 @@ class LongNameMultiplexer : public MicroPropsGenerator, public UMemory {
     static LongNameMultiplexer *forMeasureUnits(const Locale &loc,
                                                 const MaybeStackVector<MeasureUnit> &units,
                                                 const UNumberUnitWidth &width,
-                                                StringPiece unitDisplayCase,
+                                                const char *unitDisplayCase,
                                                 const PluralRules *rules,
                                                 const MicroPropsGenerator *parent,
                                                 UErrorCode &status);
diff --git a/icu4c/source/i18n/unicode/measunit.h b/icu4c/source/i18n/unicode/measunit.h
index cedf6ea..ead3dee 100644
--- a/icu4c/source/i18n/unicode/measunit.h
+++ b/icu4c/source/i18n/unicode/measunit.h
@@ -32,6 +32,12 @@ U_NAMESPACE_BEGIN
 class StringEnumeration;
 class MeasureUnitImpl;
 
+namespace number {
+namespace impl {
+class LongNameHandler;
+}
+} // namespace number
+
 #ifndef U_HIDE_DRAFT_API
 /**
  * Enumeration for unit complexity. There are three levels:
@@ -3708,6 +3714,9 @@ class U_I18N_API MeasureUnit: public UObject {
     LocalArray<MeasureUnit> splitToSingleUnitsImpl(int32_t& outCount, UErrorCode& status) const;
 
     friend class MeasureUnitImpl;
+
+    // For access to findBySubType
+    friend class number::impl::LongNameHandler;
 };
 
 #ifndef U_HIDE_DRAFT_API  // @draft ICU 68
diff --git a/icu4c/source/test/intltest/numbertest.h b/icu4c/source/test/intltest/numbertest.h
index 12ce045..3285ff7 100644
--- a/icu4c/source/test/intltest/numbertest.h
+++ b/icu4c/source/test/intltest/numbertest.h
@@ -59,6 +59,7 @@ class NumberFormatterApiTest : public IntlTestWithFieldPosition {
     void notationCompact();
     void unitMeasure();
     void unitCompoundMeasure();
+    void unitArbitraryMeasureUnits();
     void unitSkeletons();
     void unitUsage();
     void unitUsageErrorCodes();
@@ -174,6 +175,7 @@ class NumberFormatterApiTest : public IntlTestWithFieldPosition {
       int32_t length);
 
     struct UnitInflectionTestCase {
+        const char *unitIdentifier;
         const char *locale;
         const char *unitDisplayCase;
         double value;
@@ -181,10 +183,10 @@ class NumberFormatterApiTest : public IntlTestWithFieldPosition {
     };
 
     void runUnitInflectionsTestCases(UnlocalizedNumberFormatter unf,
-                                     const UChar *skeleton,
-                                     const UChar *conciseSkeleton,
+                                     UnicodeString skeleton,
                                      const UnitInflectionTestCase *cases,
-                                     int32_t numCases);
+                                     int32_t numCases,
+                                     IcuTestErrorCode &status);
 };
 
 class DecimalQuantityTest : public IntlTest {
diff --git a/icu4c/source/test/intltest/numbertest_api.cpp b/icu4c/source/test/intltest/numbertest_api.cpp
index 8ddaa53..77be3ae 100644
--- a/icu4c/source/test/intltest/numbertest_api.cpp
+++ b/icu4c/source/test/intltest/numbertest_api.cpp
@@ -80,6 +80,7 @@ void NumberFormatterApiTest::runIndexedTest(int32_t index, UBool exec, const cha
         TESTCASE_AUTO(notationCompact);
         TESTCASE_AUTO(unitMeasure);
         TESTCASE_AUTO(unitCompoundMeasure);
+        TESTCASE_AUTO(unitArbitraryMeasureUnits);
         TESTCASE_AUTO(unitSkeletons);
         TESTCASE_AUTO(unitUsage);
         TESTCASE_AUTO(unitUsageErrorCodes);
@@ -584,22 +585,21 @@ void NumberFormatterApiTest::unitMeasure() {
             u"0.0088 meters",
             u"0 meters");
 
-//     // TODO(ICU-20941): Support formatting for not-built-in units
-//     assertFormatDescending(
-//             u"Hectometers",
-//             u"measure-unit/length-hectometer",
-//             u"unit/hectometer",
-//             NumberFormatter::with().unit(MeasureUnit::forIdentifier("hectometer", status)),
-//             Locale::getEnglish(),
-//             u"87,650 hm",
-//             u"8,765 hm",
-//             u"876.5 hm",
-//             u"87.65 hm",
-//             u"8.765 hm",
-//             u"0.8765 hm",
-//             u"0.08765 hm",
-//             u"0.008765 hm",
-//             u"0 hm");
+    assertFormatDescending(
+            u"Hectometers",
+            u"unit/hectometer",
+            u"unit/hectometer",
+            NumberFormatter::with().unit(MeasureUnit::forIdentifier("hectometer", status)),
+            Locale::getEnglish(),
+            u"87,650 hm",
+            u"8,765 hm",
+            u"876.5 hm",
+            u"87.65 hm",
+            u"8.765 hm",
+            u"0.8765 hm",
+            u"0.08765 hm",
+            u"0.008765 hm",
+            u"0 hm");
 
 //    TODO: Implement Measure in C++
 //    assertFormatSingleMeasure(
@@ -717,15 +717,14 @@ void NumberFormatterApiTest::unitMeasure() {
             5,
             u"5 a\u00F1os");
 
-    // TODO(ICU-20941): arbitrary unit formatting
-//     assertFormatSingle(
-//             u"Hubble Constant",
-//             u"unit/kilometer-per-megaparsec-second",
-//             u"unit/kilometer-per-megaparsec-second",
-//             NumberFormatter::with().unit(MeasureUnit::forIdentifier("kilometer-per-megaparsec-second", status)),
-//             Locale("en"),
-//             74, // Approximate 2019-03-18 measurement
-//             u"74 km/s.Mpc");
+    assertFormatSingle(
+            u"Hubble Constant - usually expressed in km/s/Mpc",
+            u"unit/kilometer-per-megaparsec-second",
+            u"unit/kilometer-per-megaparsec-second",
+            NumberFormatter::with().unit(MeasureUnit::forIdentifier("kilometer-per-second-per-megaparsec", status)),
+            Locale("en"),
+            74, // Approximate 2019-03-18 measurement
+            u"74 km/Mpc⋅sec");
 
     assertFormatSingle(
             u"Mixed unit",
@@ -1060,7 +1059,7 @@ void NumberFormatterApiTest::unitCompoundMeasure() {
     status.assertSuccess(); // Error is only returned once we try to format.
     FormattedNumber num = nf.formatDouble(2.4, status);
     if (!status.expectErrorAndReset(U_UNSUPPORTED_ERROR)) {
-        errln(UnicodeString("Expected failure, got: \"") +
+        errln(UnicodeString("Expected failure for unit/furlong-pascal per-unit/length-meter, got: \"") +
               nf.formatDouble(2.4, status).toString(status) + "\".");
         status.assertSuccess();
     }
@@ -1088,6 +1087,167 @@ void NumberFormatterApiTest::unitCompoundMeasure() {
             u"2.4 m/s\u00B2");
 }
 
+void NumberFormatterApiTest::unitArbitraryMeasureUnits() {
+    IcuTestErrorCode status(*this, "unitArbitraryMeasureUnits()");
+
+    // TODO: fix after data bug is resolved? See CLDR-14510.
+//     assertFormatSingle(
+//             u"Binary unit prefix: kibibyte",
+//             u"unit/kibibyte",
+//             u"unit/kibibyte",
+//             NumberFormatter::with().unit(MeasureUnit::forIdentifier("kibibyte", status)),
+//             Locale("en-GB"),
+//             2.4,
+//             u"2.4 KiB");
+
+    assertFormatSingle(
+            u"Binary unit prefix: kibibyte full-name",
+            u"unit/kibibyte unit-width-full-name",
+            u"unit/kibibyte unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("kibibyte", status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("en-GB"),
+            2.4,
+            u"2.4 kibibytes");
+
+    assertFormatSingle(
+            u"Binary unit prefix: kibibyte full-name",
+            u"unit/kibibyte unit-width-full-name",
+            u"unit/kibibyte unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("kibibyte", status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("de"),
+            2.4,
+            u"2,4 Kibibyte");
+
+    assertFormatSingle(
+            u"Binary prefix for non-digital units: kibimeter",
+            u"unit/kibimeter",
+            u"unit/kibimeter",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("kibimeter", status)),
+            Locale("en-GB"),
+            2.4,
+            u"2.4 Kim");
+
+    assertFormatSingle(
+            u"SI prefix falling back to root: microohm",
+            u"unit/microohm",
+            u"unit/microohm",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("microohm", status)),
+            Locale("de-CH"),
+            2.4,
+            u"2.4 μΩ");
+
+    assertFormatSingle(
+            u"de-CH fallback to de: microohm unit-width-full-name",
+            u"unit/microohm unit-width-full-name",
+            u"unit/microohm unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("microohm", status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("de-CH"),
+            2.4,
+            u"2.4\u00A0Mikroohm");
+
+    assertFormatSingle(
+            u"No prefixes, 'times' pattern: joule-furlong",
+            u"unit/joule-furlong",
+            u"unit/joule-furlong",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("joule-furlong", status)),
+            Locale("en"),
+            2.4,
+            u"2.4 J⋅fur");
+
+    assertFormatSingle(
+            u"No numeratorUnitString: per-second",
+            u"unit/per-second",
+            u"unit/per-second",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("per-second", status)),
+            Locale("de-CH"),
+            2.4,
+            u"2.4/s");
+
+    assertFormatSingle(
+            u"No numeratorUnitString: per-second unit-width-full-name",
+            u"unit/per-second unit-width-full-name",
+            u"unit/per-second unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("per-second", status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("de-CH"),
+            2.4,
+            u"2.4 pro Sekunde");
+
+    assertFormatSingle(
+            u"Prefix in the denominator: nanogram-per-picobarrel",
+            u"unit/nanogram-per-picobarrel",
+            u"unit/nanogram-per-picobarrel",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("nanogram-per-picobarrel", status)),
+            Locale("en-ZA"),
+            2.4,
+            u"2,4 ng/pbbl");
+
+    assertFormatSingle(
+            u"Prefix in the denominator: nanogram-per-picobarrel unit-width-full-name",
+            u"unit/nanogram-per-picobarrel unit-width-full-name",
+            u"unit/nanogram-per-picobarrel unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("nanogram-per-picobarrel", status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("en-ZA"),
+            2.4,
+            u"2,4 nanograms per picobarrel");
+
+    // Valid MeasureUnit, but unformattable, because we only have patterns for
+    // pow2 and pow3 at this time:
+    LocalizedNumberFormatter lnf = NumberFormatter::with()
+              .unit(MeasureUnit::forIdentifier("pow4-mile", status))
+              .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME)
+              .locale("en-ZA");
+    lnf.formatInt(1, status);
+    status.expectErrorAndReset(U_RESOURCE_TYPE_MISMATCH);
+
+    assertFormatSingle(
+            u"kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            u"unit/kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            u"unit/kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("kibijoule-foot-per-cubic-gigafurlong-square-second",
+                                                 status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("en-ZA"),
+            2.4,
+            u"2,4 kibijoule-feet per cubic gigafurlong-square second");
+
+    assertFormatSingle(
+            u"kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            u"unit/kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            u"unit/kibijoule-foot-per-cubic-gigafurlong-square-second unit-width-full-name",
+            NumberFormatter::with()
+                .unit(MeasureUnit::forIdentifier("kibijoule-foot-per-cubic-gigafurlong-square-second",
+                                                 status))
+                .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME),
+            Locale("de-CH"),
+            2.4,
+            u"2.4\u00A0Kibijoule⋅Fuss pro Kubikgigafurlong⋅Quadratsekunde");
+
+    // TODO(ICU-21504): We want to be able to format this, but "100-kilometer"
+    // is not yet supported when it's not part of liter-per-100-kilometer:
+    lnf = NumberFormatter::with()
+              .unit(MeasureUnit::forIdentifier("kilowatt-hour-per-100-kilometer", status))
+              .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME)
+              .locale("en-ZA");
+    lnf.formatInt(1, status);
+    status.expectErrorAndReset(U_UNSUPPORTED_ERROR);
+}
+
 // TODO: merge these tests into numbertest_skeletons.cpp instead of here:
 void NumberFormatterApiTest::unitSkeletons() {
     const struct TestCase {
@@ -1929,28 +2089,37 @@ void NumberFormatterApiTest::unitCurrency() {
 }
 
 void NumberFormatterApiTest::runUnitInflectionsTestCases(UnlocalizedNumberFormatter unf,
-                                                         const UChar *skeleton,
-                                                         const UChar *conciseSkeleton,
+                                                         UnicodeString skeleton,
                                                          const UnitInflectionTestCase *cases,
-                                                         int32_t numCases) {
+                                                         int32_t numCases,
+                                                         IcuTestErrorCode &status) {
     for (int32_t i = 0; i < numCases; i++) {
         UnitInflectionTestCase t = cases[i];
+        status.assertSuccess();
+        MeasureUnit mu = MeasureUnit::forIdentifier(t.unitIdentifier, status);
+        if (status.errIfFailureAndReset("MeasureUnit::forIdentifier(\"%s\", ...) failed",
+                                        t.unitIdentifier)) {
+            continue;
+        };
+        UnicodeString skelString = UnicodeString("unit/") + t.unitIdentifier + u" " + skeleton;
         const UChar *skel;
         const UChar *cSkel;
         if (t.unitDisplayCase == nullptr || t.unitDisplayCase[0] == 0) {
-            unf = unf.unitDisplayCase("");
-            skel = skeleton;
-            cSkel = conciseSkeleton;
+            unf = unf.unit(mu).unitDisplayCase("");
+            skel = skelString.getTerminatedBuffer();
+            cSkel = skelString.getTerminatedBuffer();
         } else {
-            unf = unf.unitDisplayCase(t.unitDisplayCase);
+            unf = unf.unit(mu).unitDisplayCase(t.unitDisplayCase);
+            // No skeleton support for unitDisplayCase yet.
             skel = nullptr;
             cSkel = nullptr;
         }
-        assertFormatSingle((UnicodeString("\"") + skeleton + u"\", locale=\"" + t.locale +
-                            u"\", case=\"" + (t.unitDisplayCase ? t.unitDisplayCase : "") +
-                            u"\", value=" + t.value)
+        assertFormatSingle((UnicodeString("Unit: \"") + t.unitIdentifier + ("\", \"") + skeleton +
+                            u"\", locale=\"" + t.locale + u"\", case=\"" +
+                            (t.unitDisplayCase ? t.unitDisplayCase : "") + u"\", value=" + t.value)
                                .getTerminatedBuffer(),
                            skel, cSkel, unf, Locale(t.locale), t.value, t.expected);
+        status.assertSuccess();
     }
 }
 
@@ -1959,110 +2128,122 @@ void NumberFormatterApiTest::unitInflections() {
 
     UnlocalizedNumberFormatter unf;
     const UChar *skeleton;
-    const UChar *conciseSkeleton;
     {
         // Simple inflected form test - test case based on the example in CLDR's
         // grammaticalFeatures.xml
-        unf = NumberFormatter::with().unit(NoUnit::percent()).unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"percent unit-width-full-name";
-        conciseSkeleton = u"% unit-width-full-name";
+        unf = NumberFormatter::with().unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
+        skeleton = u"unit-width-full-name";
         const UnitInflectionTestCase percentCases[] = {
-            {"ru", nullptr, 10, u"10 процентов"},    // many
-            {"ru", "genitive", 10, u"10 процентов"}, // many
-            {"ru", nullptr, 33, u"33 процента"},     // few
-            {"ru", "genitive", 33, u"33 процентов"}, // few
-            {"ru", nullptr, 1, u"1 процент"},        // one
-            {"ru", "genitive", 1, u"1 процента"},    // one
+            {"percent", "ru", nullptr, 10, u"10 процентов"},    // many
+            {"percent", "ru", "genitive", 10, u"10 процентов"}, // many
+            {"percent", "ru", nullptr, 33, u"33 процента"},     // few
+            {"percent", "ru", "genitive", 33, u"33 процентов"}, // few
+            {"percent", "ru", nullptr, 1, u"1 процент"},        // one
+            {"percent", "ru", "genitive", 1, u"1 процента"},    // one
         };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, percentCases,
-                                    UPRV_LENGTHOF(percentCases));
+        runUnitInflectionsTestCases(unf, skeleton, percentCases, UPRV_LENGTHOF(percentCases), status);
     }
     {
-        // Testing "de" rules:
-        // <deriveComponent feature="case" structure="per" value0="compound" value1="accusative"/>
-        // <deriveComponent feature="plural" structure="per" value0="compound" value1="one"/>
-        //
-        // per-patterns use accusative, but happen to match nominative, so we're
-        // not testing value1 in the first rule above.
-
-        unf = NumberFormatter::with().unit(MeasureUnit::getMeter()).unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"unit/meter unit-width-full-name";
-        conciseSkeleton = u"unit/meter unit-width-full-name";
+        // General testing of inflection rules
+        unf = NumberFormatter::with().unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
+        skeleton = u"unit-width-full-name";
         const UnitInflectionTestCase meterCases[] = {
-            {"de", nullptr, 1, u"1 Meter"},
-            {"de", "genitive", 1, u"1 Meters"},
-            {"de", nullptr, 2, u"2 Meter"},
-            {"de", "dative", 2, u"2 Metern"},
-        };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, meterCases,
-                                    UPRV_LENGTHOF(meterCases));
+            // Check up on the basic values that the compound patterns below are
+            // derived from:
+            {"meter", "de", nullptr, 1, u"1 Meter"},
+            {"meter", "de", "genitive", 1, u"1 Meters"},
+            {"meter", "de", nullptr, 2, u"2 Meter"},
+            {"meter", "de", "dative", 2, u"2 Metern"},
+            {"mile", "de", nullptr, 1, u"1 Meile"},
+            {"mile", "de", nullptr, 2, u"2 Meilen"},
+            {"day", "de", nullptr, 1, u"1 Tag"},
+            {"day", "de", "genitive", 1, u"1 Tages"},
+            {"day", "de", nullptr, 2, u"2 Tage"},
+            {"day", "de", "dative", 2, u"2 Tagen"},
+            {"decade", "de", nullptr, 1, u"1\u00A0Jahrzehnt"},
+            {"decade", "de", nullptr, 2, u"2\u00A0Jahrzehnte"},
 
-        unf = NumberFormatter::with().unit(MeasureUnit::getDay()).unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"unit/day unit-width-full-name";
-        conciseSkeleton = u"unit/day unit-width-full-name";
-        const UnitInflectionTestCase dayCases[] = {
-            {"de", nullptr, 1, u"1 Tag"},
-            {"de", "genitive", 1, u"1 Tages"},
-            {"de", nullptr, 2, u"2 Tage"},
-            {"de", "dative", 2, u"2 Tagen"},
-        };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, dayCases, UPRV_LENGTHOF(dayCases));
+            // Testing de "per" rules:
+            //   <deriveComponent feature="case" structure="per" value0="compound" value1="accusative"/>
+            //   <deriveComponent feature="plural" structure="per" value0="compound" value1="one"/>
+            // per-patterns use accusative, but since the accusative form
+            // matches the nominative form, we're not effectively testing value1
+            // in the "case & per" rule above.
 
-        // Day has a perUnitPattern
-        unf = NumberFormatter::with()
-                  .unit(MeasureUnit::forIdentifier("meter-per-day", status))
-                  .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"unit/meter-per-day unit-width-full-name";
-        conciseSkeleton = u"unit/meter-per-day unit-width-full-name";
-        const UnitInflectionTestCase meterPerDayCases[] = {
-            {"de", nullptr, 1, u"1 Meter pro Tag"},
-            {"de", "genitive", 1, u"1 Meters pro Tag"},
-            {"de", nullptr, 2, u"2 Meter pro Tag"},
-            {"de", "dative", 2, u"2 Metern pro Tag"},
-            // testing code path that falls back to "root" but does not inflect:
-            {"af", nullptr, 1, u"1 meter per dag"},
-            {"af", "dative", 1, u"1 meter per dag"},
-        };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, meterPerDayCases,
-                                    UPRV_LENGTHOF(meterPerDayCases));
+            // We have a perUnitPattern for "day" in de, so "per" rules are not
+            // applied for these:
+            {"meter-per-day", "de", nullptr, 1, u"1 Meter pro Tag"},
+            {"meter-per-day", "de", "genitive", 1, u"1 Meters pro Tag"},
+            {"meter-per-day", "de", nullptr, 2, u"2 Meter pro Tag"},
+            {"meter-per-day", "de", "dative", 2, u"2 Metern pro Tag"},
 
-        // Decade does not have a perUnitPattern at this time (CLDR 39 / ICU
-        // 69), so we can test for the correct form of the per part:
-        unf = NumberFormatter::with()
-                  .unit(MeasureUnit::forIdentifier("parsec-per-decade", status))
-                  .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"unit/parsec-per-decade unit-width-full-name";
-        conciseSkeleton = u"unit/parsec-per-decade unit-width-full-name";
-        // Fragile test cases: these cases will break when whitespace is more
-        // consistently applied.
-        const UnitInflectionTestCase parsecPerDecadeCases[] = {
-            {"de", nullptr, 1, u"1\u00A0Parsec pro Jahrzehnt"},
-            {"de", "genitive", 1, u"1 Parsec pro Jahrzehnt"},
-            {"de", nullptr, 2, u"2\u00A0Parsec pro Jahrzehnt"},
-            {"de", "dative", 2, u"2 Parsec pro Jahrzehnt"},
+            // testing code path that falls back to "root" grammaticalFeatures
+            // but does not inflect:
+            {"meter-per-day", "af", nullptr, 1, u"1 meter per dag"},
+            {"meter-per-day", "af", "dative", 1, u"1 meter per dag"},
+
+            // Decade does not have a perUnitPattern at this time (CLDR 39 / ICU
+            // 69), so we can use it to test for selection of correct plural form.
+            // - Note: fragile test cases, these cases will break when
+            //   whitespace is more consistently applied.
+            {"parsec-per-decade", "de", nullptr, 1, u"1\u00A0Parsec pro Jahrzehnt"},
+            {"parsec-per-decade", "de", "genitive", 1, u"1 Parsec pro Jahrzehnt"},
+            {"parsec-per-decade", "de", nullptr, 2, u"2\u00A0Parsec pro Jahrzehnt"},
+            {"parsec-per-decade", "de", "dative", 2, u"2 Parsec pro Jahrzehnt"},
+
+            // Testing de "times", "power" and "prefix" rules:
+            //
+            //   <deriveComponent feature="plural" structure="times" value0="one"  value1="compound"/>
+            //   <deriveComponent feature="case" structure="times" value0="nominative"  value1="compound"/>
+            //
+            //   <deriveComponent feature="plural" structure="prefix" value0="one"  value1="compound"/>
+            //   <deriveComponent feature="case" structure="prefix" value0="nominative"  value1="compound"/>
+            //
+            // Prefixes in German don't change with plural or case, so these
+            // tests can't test value0 of the following two rules:
+            //   <deriveComponent feature="plural" structure="power" value0="one"  value1="compound"/>
+            //   <deriveComponent feature="case" structure="power" value0="nominative"  value1="compound"/>
+            {"square-decimeter-dekameter", "de", nullptr, 1, u"1 Quadratdezimeter⋅Dekameter"},
+            {"square-decimeter-dekameter", "de", "genitive", 1, u"1 Quadratdezimeter⋅Dekameters"},
+            {"square-decimeter-dekameter", "de", nullptr, 2, u"2 Quadratdezimeter⋅Dekameter"},
+            {"square-decimeter-dekameter", "de", "dative", 2, u"2 Quadratdezimeter⋅Dekametern"},
+            // Feminine "Meile" better demonstrates singular-vs-plural form:
+            {"cubic-mile-dekamile", "de", nullptr, 1, u"1 Kubikmeile⋅Dekameile"},
+            {"cubic-mile-dekamile", "de", nullptr, 2, u"2 Kubikmeile⋅Dekameilen"},
+
+            // French handles plural "times" and "power" structures differently:
+            // plural form impacts all "numerator" units (denominator remains
+            // singular like German), and "pow2" prefixes have different forms
+            //   <deriveComponent feature="plural" structure="times" value0="compound"  value1="compound"/>
+            //   <deriveComponent feature="plural" structure="power" value0="compound"  value1="compound"/>
+            // TODO: this looks wrong, and will change if CLDR-14533 causes a change:
+            {"square-decimeter-square-second", "fr", nullptr, 1, u"1\u00A0décimètre carréseconde carrée"},
+            {"square-decimeter-square-second", "fr", nullptr, 2, u"2\u00A0décimètres carréssecondes carrées"},
         };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, parsecPerDecadeCases,
-                                    UPRV_LENGTHOF(parsecPerDecadeCases));
+        runUnitInflectionsTestCases(unf, skeleton, meterCases, UPRV_LENGTHOF(meterCases), status);
     }
     {
         // Testing inflection of mixed units:
-        unf = NumberFormatter::with()
-                  .unit(MeasureUnit::forIdentifier("meter-and-centimeter", status))
-                  .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
-        skeleton = u"unit/meter-and-centimeter unit-width-full-name";
-        conciseSkeleton = u"unit/meter-and-centimeter unit-width-full-name";
+        unf = NumberFormatter::with().unitWidth(UNUM_UNIT_WIDTH_FULL_NAME);
+        skeleton = u"unit-width-full-name";
         const UnitInflectionTestCase meterPerDayCases[] = {
+            {"meter", "de", nullptr, 1, u"1 Meter"},
+            {"meter", "de", "genitive", 1, u"1 Meters"},
+            {"meter", "de", "dative", 2, u"2 Metern"},
+            {"centimeter", "de", nullptr, 1, u"1 Zentimeter"},
+            {"centimeter", "de", "genitive", 1, u"1 Zentimeters"},
+            {"centimeter", "de", "dative", 10, u"10 Zentimetern"},
             // TODO(CLDR-14502): check that these inflections are correct, and
             // whether CLDR needs any rules for them (presumably CLDR spec
             // should mention it, if it's a consistent rule):
-            {"de", nullptr, 1.01, u"1 Meter, 1 Zentimeter"},
-            {"de", "genitive", 1.01, u"1 Meters, 1 Zentimeters"},
-            {"de", "genitive", 1.1, u"1 Meters, 10 Zentimeter"},
-            {"de", "dative", 1.1, u"1 Meter, 10 Zentimetern"},
-            {"de", "dative", 2.1, u"2 Metern, 10 Zentimetern"},
+            {"meter-and-centimeter", "de", nullptr, 1.01, u"1 Meter, 1 Zentimeter"},
+            {"meter-and-centimeter", "de", "genitive", 1.01, u"1 Meters, 1 Zentimeters"},
+            {"meter-and-centimeter", "de", "genitive", 1.1, u"1 Meters, 10 Zentimeter"},
+            {"meter-and-centimeter", "de", "dative", 1.1, u"1 Meter, 10 Zentimetern"},
+            {"meter-and-centimeter", "de", "dative", 2.1, u"2 Metern, 10 Zentimetern"},
         };
-        runUnitInflectionsTestCases(unf, skeleton, conciseSkeleton, meterPerDayCases,
-                                    UPRV_LENGTHOF(meterPerDayCases));
+        runUnitInflectionsTestCases(unf, skeleton, meterPerDayCases, UPRV_LENGTHOF(meterPerDayCases),
+                                    status);
     }
     // TODO: add a usage case that selects between preferences with different
     // genders (e.g. year, month, day, hour).
@@ -2078,16 +2259,26 @@ void NumberFormatterApiTest::unitGender() {
         const char *expectedGender;
     } cases[] = {
         {"de", "meter", "masculine"},
+        {"de", "second", "feminine"},
         {"de", "minute", "feminine"},
         {"de", "hour", "feminine"},
         {"de", "day", "masculine"},
         {"de", "year", "neuter"},
+        {"fr", "meter", "masculine"},
+        {"fr", "second", "feminine"},
         {"fr", "minute", "feminine"},
         {"fr", "hour", "feminine"},
         {"fr", "day", "masculine"},
-        // grammaticalFeatures deriveCompound "per" rule:
+        // grammaticalFeatures deriveCompound "per" rule takes the gender of the
+        // numerator unit:
         {"de", "meter-per-hour", "masculine"},
-        {"af", "meter-per-hour", ""},
+        {"fr", "meter-per-hour", "masculine"},
+        {"af", "meter-per-hour", ""}, // ungendered language
+        // French "times" takes gender from first value, German takes the
+        // second. Prefix and power does not have impact on gender for these
+        // languages:
+        {"de", "square-decimeter-square-second", "feminine"},
+        {"fr", "square-decimeter-square-second", "masculine"},
         // TODO(ICU-21494): determine whether list genders behave as follows,
         // and implement proper getListGender support (covering more than just
         // two genders):
@@ -2101,13 +2292,22 @@ void NumberFormatterApiTest::unitGender() {
     FormattedNumber fn;
     for (const TestCase &t : cases) {
         // TODO(icu-units#140): make this work for more than just UNUM_UNIT_WIDTH_FULL_NAME
+        // formatter = NumberFormatter::with()
+        //                 .unit(MeasureUnit::forIdentifier(t.unitIdentifier, status))
+        //                 .locale(Locale(t.locale));
+        // fn = formatter.formatDouble(1.1, status);
+        // assertEquals(UnicodeString("Testing gender with default width, unit: ") + t.unitIdentifier +
+        //                  ", locale: " + t.locale,
+        //              t.expectedGender, fn.getGender(status));
+        // status.assertSuccess();
+
         formatter = NumberFormatter::with()
                         .unit(MeasureUnit::forIdentifier(t.unitIdentifier, status))
                         .unitWidth(UNUM_UNIT_WIDTH_FULL_NAME)
                         .locale(Locale(t.locale));
         fn = formatter.formatDouble(1.1, status);
-        assertEquals(UnicodeString("Testing gender, unit: ") + t.unitIdentifier +
-                         ", locale: " + t.locale,
+        assertEquals(UnicodeString("Testing gender with UNUM_UNIT_WIDTH_FULL_NAME, unit: ") +
+                         t.unitIdentifier + ", locale: " + t.locale,
                      t.expectedGender, fn.getGender(status));
         status.assertSuccess();
     }