Formats argument unit to string with type, position, and text content

@param argumentUnit argument unit
@return string
168033
public static String argumentUnitToString(ArgumentUnit argumentUnit)
    {
        return String.format("%s [%d, %d] \"%s\"", argumentUnit.getType().getShortName(),
                argumentUnit.getBegin(), argumentUnit.getEnd(), argumentUnit.getCoveredText());
    }
594372
private static String convertArgs(String[] args)
    {
        StringBuilder result = new StringBuilder();
        for (int i = 0; i < args.length; i++)
        {
            result.append(args[i]);
            if (i < args.length - 1)
            {
                result.append(' ');
            }
        }
        return result.toString().toUpperCase();
    }
193422
public static void setIsImplicit(ArgumentUnit argumentUnit, boolean implicit)
            throws IllegalArgumentException
    {
        int length = argumentUnit.getEnd() - argumentUnit.getBegin();

        if (length > 0) {
            throw new IllegalArgumentException("Cannot set 'implicit' property to component " +
                    "with non-zero length (" + length + ")");
        }

        ArgumentUnitUtils.setProperty(argumentUnit, ArgumentUnitUtils.PROP_KEY_IS_IMPLICIT,
                Boolean.valueOf(implicit).toString());
    }
1269132
@ArgumentsChecked
	@Throws(IllegalNullArgumentException.class)
	private static String format(@Nonnull final Class<? extends Annotation> annotation) {
		if (annotation == null) {
			throw new IllegalNullArgumentException("annotation");
		}
		return String.format(MESSAGE_WITH_ANNOTATION, annotation.getName());
	}
1304748
public static String getText(String key, ResourceBundle bundle, Object... arguments)
	{
		try
		{
			String value = bundle.getString(key);

			return MessageFormat.format(value, arguments);
		}
		catch (MissingResourceException ex)
		{
			return key;
		}
	}
268621
function format (args) {
  return args.map((v) => {
    const type = Object.prototype.toString.call(v)
    if (type.toLowerCase() === '[object object]') {
      v = JSON.stringify(v)
    }
    else {
      v = String(v)
    }
    return v
  })
}
303888
def arg_type_to_string(arg_type) -> str:
    

    union_params = (
        getattr(arg_type, '__union_params__', None) or
        getattr(arg_type, '__args__', None)
    )

    if union_params and isinstance(union_params, (list, tuple)):
        return ', '.join([arg_type_to_string(item) for item in union_params])

    try:
        return arg_type.__name__
    except AttributeError:
        return '{}'.format(arg_type)
873774
private String formatArgs(String format, Object... args) {
    if (format != null) {
      return String.format(format, args);
    } else {
      StringBuilder sb = new StringBuilder();
      for (int i = 0, N = args.length; i < N; i++) {
        if (i != 0) {
          sb.append(", ");
        }
        sb.append(args[i]);
      }
      return sb.toString();
    }
  }
1216324
@Override
    public Map<String, String> getArgumentsAsMap() {
        Map<String, String> variables = new VariableFromCsvFileReader(getFileName()).getDataAsMap(getVariablePrefix(), getSeparator(), getSkipLines());
        //store in System Properties also
        if (isStoreAsSystemProperty()) {
            for (Map.Entry<String, String> element : variables.entrySet()) {
                String variable = element.getKey();
                if (System.getProperty(variable) == null) {
                    System.setProperty(variable, element.getValue());
                }
            }
        }

        return variables;
    }
76519
public StringBuffer render(StringBuffer buffer, Object... arguments)
    {

        return format(arguments, buffer, null);

    }
779660
public static void formatLatitude(Appendable out, double latitude, UnitType unit)
    {
        formatLatitude(out, Locale.getDefault(), latitude, unit);
    }
1157857
private Format getFormatter(final String pattern, final Object argument) {
		if (pattern.indexOf('|') != -1) {
			int start = pattern.indexOf('{');
			if (start >= 0 && start < pattern.lastIndexOf('}')) {
				return new ChoiceFormat(format(pattern, new Object[] { argument }));
			} else {
				return new ChoiceFormat(pattern);
			}
		} else {
			return new DecimalFormat(pattern, symbols);
		}
	}
992436
function format (str, ...args) {
  return str.replace(/{(\d+)}/g, function (match, number) {
    return typeof args[number] === 'undefined'
      ? match
      : args[number]
    ;
  })
}
366807
public static String formatInput(ReplaceableString input,
                                     Transliterator.Position pos) {
        StringBuffer appendTo = new StringBuffer();
        formatInput(appendTo, input, pos);
        return android.icu.impl.Utility.escape(appendTo.toString());
    }
626705
public String formatAsString(final Cell cell, final Locale locale) {
        return format(cell, locale).getText();
    }
1019125
public static String format(final String messagePattern, final Object[] arguments) {
        return ParameterFormatter.format(messagePattern, arguments);
    }
1225094
protected String format(String format, Object... args) {

    if (format == null) {
      return null;
    }
    if (args == null) {
      return format;
    }
    StringBuilder buffer = new StringBuilder();
    int argumentIndex = 0;
    int formatStartIndex = 0;
    while (formatStartIndex >= 0) {
      if (argumentIndex >= args.length) {
        // too few arguments given - append the rest of the format string
        buffer.append(format.substring(formatStartIndex));
        formatStartIndex = -1;
      } else {
        int formatEndIndex = format.indexOf("{}");
        if (formatEndIndex == -1) {
          buffer.append(format.substring(formatStartIndex));
          formatStartIndex = -1;
        } else {
          buffer.append(format.substring(formatStartIndex, formatEndIndex));
          formatStartIndex = formatEndIndex + 2;
          buffer.append(args[argumentIndex++]);
        }
      }
    }
    return buffer.toString();
  }