val certificateByteString = certificate.certificate.encoded.toByteString()

    // Valid signature.
    val okHttpCertificate =
      CertificateAdapters.certificate
        .fromDer(certificateByteString)
    println(okHttpCertificate)
    assertThat(okHttpCertificate.checkSignature(root.keyPair.public)).isTrue()

    // Invalid signature.
    val okHttpCertificateWithBadSignature =
      okHttpCertificate.copy(

                    return buf;
                }, StringIndexOutOfBoundsException.class));
    }

    @ParameterizedTest(name = "{0}")
    @MethodSource("invalidBuffers")
    @DisplayName("Invalid buffers throw appropriate exceptions")
    void invalidInputsThrow(String name, Object bufferSupplierOrBytes, Class<? extends Throwable> expected) {
        // Arrange
        byte[] buf;

            } catch (final URISyntaxException e) {
                throw new CrawlingAccessException("Invalid FTP URL: " + s, e);
            }

            if (!"ftp".equals(uri.getScheme())) {
                throw new CrawlingAccessException(
                        "Invalid FTP scheme: expected 'ftp://' but got '" + uri.getScheme() + "://' for URI: " + s);
            }

                } else if (parsed) {
                    // fallback, already expected a XmlPullParserException due to invalid XML
                    throw new XmlPullParserException("Duplicated tag: 'extensions'", parser, null);
                }
                coreExtensions = parseCoreExtensions(parser, strict);

        SimpleProblemCollector result = validate("invalid-coordinate-ids-pom.xml");

        assertViolations(result, 0, 2, 0);

        assertEquals(
                "'groupId' with value 'o/a/m' does not match a valid id pattern.",
                result.getErrors().get(0));

        assertEquals(
                "'artifactId' with value 'm$-do$' does not match a valid id pattern.",
                result.getErrors().get(1));

        validateApi(body, messages -> {});
        if (!isValidFileConfigId(body.fileConfigId)) {
            return asJson(new ApiErrorResponse().message("invalid fileConfigId").status(Status.BAD_REQUEST).result());
        }

        body.crudMode = CrudMode.CREATE;
        final FileAuthentication fileAuth = getFileAuthentication(body).map(entity -> {
            try {
                fileAuthService.store(entity);

        @Test
        public void testConstructorWithMalformedUrl() {
            // Test that constructor throws MalformedURLException for completely invalid URL
            // Note: http:// URLs are actually accepted by the URL constructor but the protocol is changed to smb
            String invalidUrl = "not-a-valid-url";
            assertThrows(MalformedURLException.class, () -> new SmbFile(invalidUrl));
        }

        @Test

        assertNotNull(resp.getErrorData(), "Error data should be present");
        assertArrayEquals(err, resp.getErrorData());
    }

    @Test
    @DisplayName("Invalid structure size should throw during decode")
    void testInvalidStructureSizeThrows() {
        Smb2SessionSetupResponse resp = newResponse();

        byte[] buf = new byte[128];
        int headerStart = 0;

		fallthrough
	case "keyInvalid":
		fallthrough
	case "forbidden":
		err = PrefixAccessDenied{
			Bucket: bucket,
			Object: object,
		}
	case "invalid":
		err = BucketNameInvalid{
			Bucket: bucket,
		}
	case "notFound":
		if object != "" {
			err = ObjectNotFound{
				Bucket: bucket,
				Object: object,
			}
			break
		}

    // Cache implementors may want to catch it but should not need to be able to throw it.
    UnsupportedLoadingOperationException() {}
  }

  /**
   * Thrown to indicate that an invalid response was returned from a call to {@link CacheLoader}.
   *
   * @since 11.0
   */
  public static final class InvalidCacheLoadException extends RuntimeException {