}

        final String[] cmds = stream(commands).get(stream -> stream.map(s -> {
            if ("$USERNAME".equals(s)) {
                return username;
            }
            if ("$PASSWORD".equals(s)) {
                return password;
            }
            return s;
        }).toArray(n -> new String[n]));

            if ("search_log".equals(name)) {
                return writeNdjsonResponse(id, getSearchLogNdjsonWriteCall());
            }
            if ("user_info".equals(name)) {
                return writeNdjsonResponse(id, getUserInfoNdjsonWriteCall());
            }
            if ("click_log".equals(name)) {
                return writeNdjsonResponse(id, getClickLogNdjsonWriteCall());

    }

    @Override
    public void omitForNearer(Artifact omitted, Artifact kept) {
        String omittedVersion = omitted.getVersion();
        String keptVersion = kept.getVersion();

        if (!Objects.equals(omittedVersion, keptVersion)) {
            logger.debug(indent + omitted + " (removed - nearer found: " + keptVersion + ")");
        }
    }

    @Override
    public void omitForCycle(Artifact omitted) {

        IncludesArtifactFilter f2 = new IncludesArtifactFilter(patterns);

        assertTrue(f1.equals(f2));
        assertTrue(f2.equals(f1));
        assertTrue(f1.hashCode() == f2.hashCode());

        IncludesArtifactFilter f3 = new IncludesArtifactFilter(Arrays.asList("d", "c", "e"));
        assertTrue(f1.equals(f3));
        assertTrue(f1.hashCode() == f3.hashCode());
    }

                        && Objects.equals(inactiveProfileIds, that.inactiveProfileIds)
                        && Objects.equals(systemProperties, that.systemProperties)
                        && Objects.equals(userProperties, that.userProperties)
                        && repositoryMerging == that.repositoryMerging

  /** Constructor for use by subclasses. */
  protected ForwardingSet() {}

  @Override
  protected abstract Set<E> delegate();

  @Override
  public boolean equals(@Nullable Object object) {
    return object == this || delegate().equals(object);
  }

  @Override
  public int hashCode() {
    return delegate().hashCode();
  }

  /**

        buf.append(")");
        return buf.toString();
    }

    /**
     * Returns whether the method is the {@literal equals(Object)} method.
     *
     * @param method
     *            The method. Cannot be {@literal null}
     * @return {@literal true} if the method is {@literal equals(Object)}
     */
    public static boolean isEqualsMethod(final Method method) {
        assertArgumentNotNull("method", method);

                                                value, valueSources, postProcessors, debugEnabled);

                                        if (!interpolated.equals(value)) {
                                            field.set(target, interpolated);
                                        }
                                    }

            if (other.first != null) {
                return false;
            }
        } else if (!first.equals(other.first)) {
            return false;
        }
        if (second == null) {
            if (other.second != null) {
                return false;
            }
        } else if (!second.equals(other.second)) {
            return false;
        }
        return true;
    }

        this.name = name;
    }

    /*
     * (non-Javadoc)
     *
     * @see java.lang.Object#equals(java.lang.Object)
     */
    @Override
    public boolean equals(final Object other) {

        if (other instanceof final MIEName terg) {
            if (Objects.equals(this.oid, terg.oid)