TLS (HTTPS) uses the specific port `443` by default. So that's the port we would need.

As only one process can be listening on this port, the process that would do it would be the **TLS Termination Proxy**.

  // We need to test that our method behaves like the JDK method.
  @SuppressWarnings("InlineMeInliner")
  public void testHashCode() {
    for (double value : VALUES) {
      assertThat(Doubles.hashCode(value)).isEqualTo(Double.hashCode(value));
    }
  }

  @SuppressWarnings("InlineMeInliner") // We need to test our method.
  public void testIsFinite() {

    public Slf4jStdoutLogger() {
        this(System.out);
    }

    public Slf4jStdoutLogger(PrintStream out) {
        this.out = requireNonNull(out);
    }

    //
    // These are the only methods we need in our primordial logger
    //
    @Override
    public void error(String msg) {
        out.print(ERROR);
        out.println(msg);
    }

    @Override
    public void error(String msg, Throwable t) {

 *
 * @author Chris Povirk
 * @author Kevin Bourrillion
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
@NullMarked

 *
 * @author Kevin Bourrillion
 * @author Chris Povirk
 */
@GwtCompatible
@Ignore("test runners must not instantiate and run this directly, only via suites we build")
// @Ignore affects the Android test runner, which respects JUnit 4 annotations on JUnit 3 tests.
@SuppressWarnings("JUnit4ClassUsedInJUnit3")
public class CollectionToArrayTester<E> extends AbstractCollectionTester<E> {

    }
    return true;
  }

  @Override
  public final void clear() {
    backingMap.clear();
    size = 0;
  }

  /**
   * Skeleton of per-entry iterators. We could push this down and win a few bytes, but it's complex
   * enough it's not especially worth it.
   */
  abstract class Itr<T extends @Nullable Object> implements Iterator<T> {
    int entryIndex = backingMap.firstIndex();

        table.put(row, column, cell);
      } else {
        oldCell.merge(value, merger);
      }
    }

    /*
     * While the current implementation returns `this`, that's not something we mean to guarantee.
     * Anyway, the purpose of this method is to implement a BinaryOperator combiner for a Collector,
     * so its return value will get used naturally.
     */

    private SmbTransport.ServerData serverData;
    private SmbComNegotiateResponse response;

    @BeforeEach
    void setUp() throws UnknownHostException {
        // To instantiate the non-static inner class ServerData, we need an instance of the outer class SmbTransport.
        UniAddress uniAddress = new UniAddress(InetAddress.getByName("127.0.0.1"));
        SmbTransport transport = new SmbTransport(uniAddress, 445, null, 0);

    @SuppressWarnings("unchecked")
    Class<TestEnum> shadowTestEnum =
        (Class<TestEnum>) Class.forName(TestEnum.class.getName(), false, shadowLoader);
    assertThat(shadowTestEnum).isNotEqualTo(TestEnum.class);
    // We can't write Set<TestEnum> because that is a Set of the TestEnum from the original
    // ClassLoader.
    Set<Object> shadowConstants = new HashSet<>();
    for (TestEnum constant : TestEnum.values()) {

			n:            27,
			want:         26,
			wantErr:      io.EOF,
			wantBuffered: 0,
		},
		// Any error from filling shouldn't show up until we
		// get past the valid bytes. Here we return 5 valid bytes at the same time
		// as an error, but test that we don't see the error from Discard.
		{
			name: "fill error, discard less",
			r: newScriptedReader(func(p []byte) (n int, err error) {
				if len(p) < 5 {