* Object#toString}.
   */
  NON_STANDARD_TOSTRING,

  /**
   * Indicates that the constructor or factory method of a collection, usually an immutable set,
   * throws an {@link IllegalArgumentException} when presented with duplicate elements instead of
   * collapsing them to a single element or including duplicate instances in the collection.
   */
  REJECTS_DUPLICATES_AT_CREATION,

  Object writeReplace() {
    return new EnumSerializedForm<E>(delegate);
  }

  @J2ktIncompatible // serialization
  private void readObject(ObjectInputStream stream) throws InvalidObjectException {
    throw new InvalidObjectException("Use SerializedForm");
  }

  /*
   * This class is used to serialize ImmutableEnumSet instances.
   */
  @J2ktIncompatible // serialization

    }

    private void parse(final byte[] material) throws IOException {
        for (int i = 0; i < 8; i++) {
            if (material[i] != NTLMSSP_SIGNATURE[i]) {
                throw new IOException("Not an NTLMSSP message.");
            }
        }
        if (readULong(material, 8) != 3) {
            throw new IOException("Not a Type 3 message.");
        }

    private Field findField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        Class<?> current = clazz;
        while (current != null) {
            try {
                return current.getDeclaredField(fieldName);
            } catch (NoSuchFieldException e) {
                current = current.getSuperclass();
            }
        }
        throw new NoSuchFieldException(fieldName);
    }

    /**
     * @param parameter add a new parameter
     * @throws DuplicateParameterException if any
     */
    public void addParameter(Parameter parameter) throws DuplicateParameterException {
        if (parameters.contains(parameter)) {
            throw new DuplicateParameterException(parameter.getName()
                    + " has been declared multiple times in mojo with goal: " + getGoal() + " (implementation: "

import okio.Timeout
import okio.buffer

/** Serves requests from the cache and writes responses to the cache. */
class CacheInterceptor(
  internal val call: RealCall,
  internal val cache: Cache?,
) : Interceptor {
  @Throws(IOException::class)
  override fun intercept(chain: Interceptor.Chain): Response {
    val cacheCandidate = cache?.get(chain.request().requestForCache())

    val now = System.currentTimeMillis()

    int major;
    int minor;

    DcerpcBinding(final String proto, final String server) {
        this.proto = proto;
        this.server = server;
    }

    void setOption(final String key, final Object val) throws DcerpcException {
        if (key.equals("endpoint")) {
            endpoint = val.toString();
            final String lep = endpoint.toLowerCase();
            if (lep.startsWith("\\pipe\\")) {

    private boolean merged;

    public MetadataBridge(ArtifactMetadata metadata) {
        this.metadata = metadata;
    }

    @Override
    public void merge(File current, File result) throws RepositoryException {
        try {
            if (current.exists()) {
                Files.createDirectories(result.toPath().getParent());
                Files.copy(current.toPath(), result.toPath());
            }

        // Then
        assertEquals(expectedLength, actualLength);
        verify(messageBlock).decode(buffer, bufferIndex);
    }

    @Test
    @DisplayName("Test decode method throws SMBProtocolDecodingException")
    void testDecodeThrowsException() throws SMBProtocolDecodingException {
        // Given
        byte[] buffer = new byte[10];
        int bufferIndex = 0;

     * @return the number of bytes read
     * @throws SMBProtocolDecodingException if decoding fails
     */
    protected int readErrorResponse(final byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
        final int start = bufferIndex;
        final int structureSize = SMBUtil.readInt2(buffer, bufferIndex);
        if (structureSize != 9) {