Shinsuke Sugaya <******@****.***> 1729904872 +0900

import okhttp3.tls.decodeCertificatePem
import org.junit.jupiter.api.Tag
import org.junit.jupiter.api.Test

/**
 * Test for new Let's Encrypt Root Certificate.
 */
@Tag("Remote")
class LetsEncryptClientTest {
  @Test fun get() {
    // These tests wont actually run before Android 8.0 as per
    // https://github.com/mannodermaus/android-junit5

  }

  @Test
  fun normalizeSingleSelfSignedCertificate() {
    val root =
      HeldCertificate
        .Builder()
        .serialNumber(1L)
        .build()
    val cleaner = get(root.certificate)
    assertThat(cleaner.clean(list(root), "hostname")).isEqualTo(list(root))
  }

  @Test
  fun normalizeUnknownSelfSignedCertificate() {
    val root =
      HeldCertificate
        .Builder()
        .serialNumber(1L)

    }

    /**
     * Verify that the message + rootCause constructor stores the root.
     */
    @Test
    @DisplayName("Message + root cause stores root cause")
    void testStringAndThrowableConstructor() {
        Throwable root = mock(Throwable.class);
        SmbException ex = new SmbException("oops", root);
        assertSame(root, ex.getRootCause());
    }

    /**

 *    certificates to establish trust from a root certificate to the server's certificate. The root
 *    certificate is not included in this chain.
 *  * The client's handshake certificates must include a set of trusted root certificates. They will
 *    be used to authenticate the server's certificate chain. Typically this is a set of well-known
 *    root certificates that is distributed with the HTTP client or its platform. It may be

     * <p>
     * If a root package is specified at instance construction, only classes under the root package are targeted.
     * </p>
     *
     * @param handler the handler to process classes
     */
    void forEach(ClassHandler handler);

    /**
     * Searches for resources handled by this instance and calls the handler for each resource.
     * <p>

import okio.Okio;

public class SampleServer extends Dispatcher {
  private final SSLContext sslContext;
  private final String root;
  private final int port;

  public SampleServer(SSLContext sslContext, String root, int port) {
    this.sslContext = sslContext;
    this.root = root;
    this.port = port;
  }

  public void run() throws IOException {
    MockWebServer server = new MockWebServer();

    }

    /**
     * Constructs a new TransportException with the specified root cause.
     *
     * @param rootCause the root cause of this exception
     */
    public TransportException(final Throwable rootCause) {
        this.rootCause = rootCause;
    }

    /**
     * Constructs a new TransportException with the specified detail message and root cause.
     *
     * @param msg the detail message

starting with its own and including everything up-to but not including the root. We don't need to
include root certificates because the client already has them.

```java
HandshakeCertificates serverHandshakeCertificates = new HandshakeCertificates.Builder()
    .heldCertificate(serverCertificate, intermediateCertificate.certificate())
    .build();
```

The client only needs to know the trusted root certificate. It checks the server's certificate by

                throws SmbAuthException {
            if (disabled)
                return null;
            return super.getReferral(trans, domain, root, path, auth);
        }

        @Override
        public synchronized DfsReferral resolve(String domain, String root, String path, NtlmPasswordAuthentication auth)