} catch (final SmbAuthException sae) {
                throw sae;
            } catch (final SmbException se) {
                fp = 0L;
            }
        }
        if (file instanceof SmbNamedPipe && file.unc.startsWith("\\pipe\\")) {
            file.unc = file.unc.substring(5);
            file.send(new TransWaitNamedPipe("\\pipe" + file.unc), new TransWaitNamedPipeResponse());
        }

    return ordering.compare(function.apply(left), function.apply(right));
  }

  @Override
  public boolean equals(@Nullable Object object) {
    if (object == this) {
      return true;
    }
    if (object instanceof ByFunctionOrdering) {
      ByFunctionOrdering<?, ?> that = (ByFunctionOrdering<?, ?>) object;
      return this.function.equals(that.function) && this.ordering.equals(that.ordering);
    }
    return false;
  }

  protected int doHash(F a) {
    return resultEquivalence.hash(function.apply(a));
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj == this) {
      return true;
    }
    if (obj instanceof FunctionalEquivalence) {
      FunctionalEquivalence<?, ?> that = (FunctionalEquivalence<?, ?>) obj;
      return function.equals(that.function) && resultEquivalence.equals(that.resultEquivalence);
    }
    return false;

    for (T element : iterable) {
      hash = hash * 24943 + elementEquivalence.hash(element);
    }
    return hash;
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof PairwiseEquivalence) {
      @SuppressWarnings("unchecked")
      PairwiseEquivalence<Object, Object> that = (PairwiseEquivalence<Object, Object>) obj;
      return this.elementEquivalence.equals(that.elementEquivalence);
    }

    private org.apache.maven.api.Toolchain getToolchainV4(ToolchainPrivate toolchain) {
        return toolchain instanceof ToolchainWrapperV3 v3tc ? v3tc.delegate : new ToolchainWrapperV4(toolchain);
    }

    private ToolchainPrivate getToolchainV3(org.apache.maven.api.Toolchain toolchain) {
        return toolchain instanceof ToolchainWrapperV4 v3tc ? v3tc.delegate : new ToolchainWrapperV3(toolchain);
    }

        return this;
    }

    @Override
    public Path getPath() {
        return null;
    }

    @Override
    public Nature getNature() {
        if (metadata instanceof RepositoryMetadata repositoryMetadata) {
            return switch (repositoryMetadata.getNature()) {
                case RepositoryMetadata.RELEASE_OR_SNAPSHOT -> Nature.RELEASE_OR_SNAPSHOT;

    }

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

    @Override
    public boolean equals(Object other) {
        return (other instanceof Parameter parameter) && getName().equals(parameter.getName());
    }

    public String getAlias() {
        return alias;
    }

    public void setAlias(String alias) {
        this.alias = alias;

        // When
        Smb2ReadResponse resp = new Smb2ReadResponse(mockConfig, buffer, offset);

        // Then
        assertNotNull(resp);
        assertTrue(resp instanceof ServerMessageBlock2Response);
        assertTrue(resp instanceof ServerMessageBlock2);
    }

    @Test
    @DisplayName("Should return correct OVERHEAD constant value")
    void testOverheadConstant() {
        // Then

        }
        return sourceMap;
    }

    @Override
    protected void addFieldToSource(final Map<String, Object> sourceMap, final String field, final Object value) {
        if (value instanceof final LocalDateTime ldt) {
            final ZonedDateTime zdt = ZonedDateTime.of(ldt, ZoneId.systemDefault());
            super.addFieldToSource(sourceMap, field, DateTimeFormatter.ISO_INSTANT.format(zdt));
        } else {

            function.apply(reference),
            "the Function passed to Optional.transform() must not return null."));
  }

  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj instanceof Present) {
      Present<?> other = (Present<?>) obj;
      return reference.equals(other.reference);
    }
    return false;
  }

  @Override
  public int hashCode() {