a[i] = 8
			b[i] = 9
		}
		cmp := Compare(a[:len], b[:len])
		if cmp != 0 {
			t.Errorf(`CompareIdentical(%d) = %d`, len, cmp)
		}
		if len > 0 {
			cmp = Compare(a[:len-1], b[:len])
			if cmp != -1 {
				t.Errorf(`CompareAshorter(%d) = %d`, len, cmp)
			}
			cmp = Compare(a[:len], b[:len-1])
			if cmp != 1 {
				t.Errorf(`CompareBshorter(%d) = %d`, len, cmp)
			}
		}
		for k := 0; k < len; k++ {

    //                                                                              Source
    //                                                                              ======
    @Override
    public Map<String, Object> toSource() {
        Map<String, Object> sourceMap = new HashMap<>();
        if (endTime != null) {
            addFieldToSource(sourceMap, "endTime", endTime);
        }
        if (jobName != null) {

        val performanceTestsCiJsonObj: Map<String, List<Map<String, Any>>> = objectMapper.readValue(performanceTestsCiJson)

        return performanceTestsCiJsonObj["performanceTests"]!!.map { scenarioObj ->
            val testId = scenarioObj["testId"] as String
            val groups =
                (scenarioObj["groups"] as List<Map<String, Any>>).map { groupObj ->

      Map<K, V> newHashMapWithExpectedSize(int expectedSize) {
    return Maps.newHashMapWithExpectedSize(expectedSize);
  }

  /**
   * Returns the platform preferred implementation of an insertion ordered map based on a hash
   * table.
   */
  static <K extends @Nullable Object, V extends @Nullable Object>
      Map<K, V> newLinkedHashMapWithExpectedSize(int expectedSize) {

  /**
   * Returns an unmodifiable map containing the entries from the left map whose keys are not present
   * in the right map.
   */
  Map<K, V> entriesOnlyOnLeft();

  /**
   * Returns an unmodifiable map containing the entries from the right map whose keys are not
   * present in the left map.
   */
  Map<K, V> entriesOnlyOnRight();

  /**

 *
 * @author James Sexton
 */
class MapIteratorCache<K, V> {
  private final Map<K, V> backingMap;

  /*
   * Per JDK: "the behavior of a map entry is undefined if the backing map has been modified after
   * the entry was returned by the iterator, except through the setValue operation on the map entry"
   * As such, this field must be cleared before every map mutation.
   *

        # If you use Oracle and its Synonym, specify this property.
        #; includeSynonyms=true
    }
    # - - - - - - - - - -/

    # /- - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
    # o variousMap: (NotRequired - Default map:{})
    #  The various settings about JDBC task mainly.
    #
    ; variousMap = map:{
        # o objectTypeTargetList: (NotRequired - Default list:{TABLE;VIEW})

                            final String label = locale.getDisplayName(displayLocale);
                            final Map<String, String> map = new HashMap<>(2);
                            map.put(Constants.ITEM_LABEL, label);
                            map.put(Constants.ITEM_VALUE, lang);
                            langItems.add(map);
                        }
                        return langItems;
                    }
                });

    protected static Map<String, String> createItem(final Object label, final Object value) {
        final Map<String, String> map = new HashMap<>(2);
        map.put(Constants.ITEM_LABEL, label != null ? label.toString() : StringUtil.EMPTY);
        map.put(Constants.ITEM_VALUE, value != null ? value.toString() : StringUtil.EMPTY);
        return map;
    }

            concreteImplementation.setKey(key);
            assertEquals(key, concreteImplementation.getKey());
        }

        @Test
        @DisplayName("Should set cache map")
        void testSetCacheMap() {
            Map<String, DfsReferralDataInternal> cacheMap = new HashMap<>();

            // Test with mock
            doNothing().when(mockReferralData).setCacheMap(cacheMap);