public Multiset<String> create(Object... elements) {
    String[] array = new String[elements.length];
    int i = 0;
    for (Object e : elements) {
      array[i++] = (String) e;
    }
    return create(array);
  }

  protected abstract Multiset<String> create(String[] elements);

  @Override
  public String[] createArray(int length) {
    return new String[length];
  }

                { "\\pipe\\samr", "samr", "12345778-1234-ABCD-EF00-0123456789AC", 1, 0 } };

        for (Object[] data : testData) {
            String endpoint = (String) data[0];
            String pipeName = (String) data[1];
            String expectedUuid = (String) data[2];
            int expectedMajor = (int) data[3];
            int expectedMinor = (int) data[4];

            // The interfaces are added in setUp()

        super.init();

        final String systemKey = getInitParameter("ftpConfigSystemKey", FTPClientConfig.SYST_UNIX, String.class);
        ftpClientConfig = new FTPClientConfig(systemKey);

        final String serverLanguageCode = getInitParameter("ftpConfigServerLanguageCode", "en", String.class);
        ftpClientConfig.setServerLanguageCode(serverLanguageCode);

func extractMetadataFromReq(ctx context.Context, r *http.Request) (metadata map[string]string, err error) {
	return extractMetadata(ctx, textproto.MIMEHeader(r.Form), textproto.MIMEHeader(r.Header))
}

func extractMetadata(ctx context.Context, mimesHeader ...textproto.MIMEHeader) (metadata map[string]string, err error) {
	metadata = make(map[string]string)

	for _, hdr := range mimesHeader {
		// Extract all query values.

    ClosingFuture<String> step2 =
        step1.transform(
            step2Waiter.waitFor(
                (ClosingFunction<String, String>)
                    (DeferredCloser closer, String v) -> {
                      closer.eventuallyClose(closeable2, closingExecutor);
                      return "value 2";
                    }),
            executor);
    ClosingFuture<String> step3 =
        step2.transform(

    // fail with message
    protected void fail(String message) {
        Assertions.fail(message);
    }

    // assertTrue - JUnit 4 style (message first)
    protected void assertTrue(String message, boolean condition) {
        Assertions.assertTrue(condition, message);
    }

    // assertTrue - JUnit 5 style (message last)
    protected void assertTrue(boolean condition, String message) {

    }

    @Nonnull
    default ArtifactCoordinates create(
            @Nonnull Session session,
            String groupId,
            String artifactId,
            String version,
            String classifier,
            String extension,
            String type) {
        return create(ArtifactCoordinatesFactoryRequest.build(

         */
        NTLM
    }

    private CredentialsType type = CredentialsType.USERNAME_PASSWORD;
    private String username;
    private String password;

    // NTLM-specific fields
    private String domain;
    private String workstation;

    /**
     * Gets the credentials type.
     *
     * @return the credentials type
     */
    public CredentialsType getType() {

        final FessConfig fessConfig = new FessConfig.SimpleImpl() {
            @Override
            public boolean isSchedulerTarget(final String target) {
                return true;
            }

            @Override
            public String getSchedulerTargetName() {
                return Constants.DEFAULT_JOB_TARGET;
            }
        };
        ComponentUtil.setFessConfig(fessConfig);

		res = append(res, fmt.Sprintf("Op: %v", m.Op))
	}
	res = append(res, fmt.Sprintf("Flags: %s", m.Flags.String()))
	if len(m.Payload) != 0 {
		res = append(res, fmt.Sprintf("Payload: %v", bytesOrLength(m.Payload)))
	}
	return "{" + strings.Join(res, ", ") + "}"
}

func (f Flags) String() string {
	var res []string
	if f&FlagCRCxxh3 != 0 {
		res = append(res, "CRC")
	}
	if f&FlagEOF != 0 {