// On OpenJDK, the handshake succeeds but the certificate pinner fails.
          assertThat(expected.message!!).startsWith("Certificate pinning failure!")
        }

        else -> {
          throw expected
        }
      }
    }
  }

  /**
   * Not checking the CA bit created a vulnerability in old OkHttp releases. It is exploited by

    }

    @SuppressWarnings("unchecked") // all methods throw immediately
    PopulatableMapAsMultimap() {
      this.map = new HashMap<>();
      this.unusableDelegate =
          (SetMultimap<K, V>)
              newProxy(
                  SetMultimap.class,
                  (proxy, method, args) -> {
                    throw new UnsupportedOperationException();
                  });
    }

        }
        printBoostAndQueryName(builder);
        builder.endObject();
    }

    @Override
    protected Query doToQuery(final QueryShardContext context) throws IOException {
        throw new UnsupportedOperationException("Query processing is not supported.");
    }

    @Override
    protected boolean doEquals(final StoredLtrQueryBuilder other) {

                for (Error err : e.getValue()) {
                    sb.append("    line ").append(err.line).append(": ").append(err.message).append("\n");
                }
            }
            throw new GradleException(sb.toString());
        }
    }

    private static final java.util.regex.Pattern SOURCE_LANG_PATTERN =
        java.util.regex.Pattern.compile(

            System.arraycopy(buffer, start, payload, 0, len);
            setRawPayload(payload);
        }

        if (!verifySignature(buffer, start, len)) {
            throw new SMBProtocolDecodingException("Signature verification failed for " + getClass().getName());
        }

        setAsyncHandled(false);
        received();
    }

    /**
     *
     * {@inheritDoc}

        dstIndex += 4;

        SMBUtil.writeInt2(dstIndex - getHeaderStart(), dst, dataOffsetOffset);

        if (dstIndex + this.dataLength > dst.length) {
            throw new IllegalArgumentException(
                    String.format("Data exceeds buffer size ( remain buffer: %d data length: %d)", dst.length - dstIndex, this.dataLength));
        }

                MavenArtifactProperties.LOCAL_PATH));

        // == sanity check
        if (result.size() != org.apache.maven.api.DependencyScope.values().length - 1) { // sans "undefined"
            throw new IllegalStateException("Maven4 API dependency scope mismatch");
        }

        return result;
    }

    @Override
    public Collection<org.eclipse.aether.scope.ResolutionScope> buildResolutionScopes(

            final byte[] payload = new byte[len];
            System.arraycopy(buffer, 4, payload, 0, len);
            setRawPayload(payload);
        }

        if (!verifySignature(buffer, 4, len)) {
            throw new SMBProtocolDecodingException("Signature verification failed for " + this.getClass().getName());
        }
        return len;
    }

    /**
     * Writes the AndX wire format to buffer

            return bytesWritten;
        }

        @Override
        protected int readBytesWireFormat(byte[] buffer, int bufferIndex) throws SMBProtocolDecodingException {
            if (throwOnRead) {
                throw new SMBProtocolDecodingException("Test exception");
            }
            return bytesRead;
        }

        public void setBytesWritten(int bytes) {
            this.bytesWritten = bytes;
        }

            throws RepositoryMetadataStoreException {
        try {
            updateRepositoryMetadata(localRepository, remoteRepository);
        } catch (IOException | XMLStreamException e) {
            throw new RepositoryMetadataStoreException("Error updating group repository metadata", e);
        }
    }

    protected void updateRepositoryMetadata(ArtifactRepository localRepository, ArtifactRepository remoteRepository)