NameServicePacket.writeInt2(NameServicePacket.IN, src, 4); // recordClass
        NameServicePacket.writeInt4(100, src, 6); // ttl
        NameServicePacket.writeInt2(6, src, 10); // rDataLength (for one NbtAddress)

        packet.questionName = mockQuestionName; // Ensure questionName is set

        int read = packet.readResourceRecordWireFormat(src, 0);

      } catch (Throwable t) {
        logger.log(Level.SEVERE, "Error cleaning up after reference.", t);
      }
    }
  }

  /**
   * Iterates through the given loaders until it finds one that can load Finalizer.
   *
   * @return Finalizer.class
   */
  private static Class<?> loadFinalizer(FinalizerLoader... loaders) {
    for (FinalizerLoader loader : loaders) {

    // The choice of the size() method to call here is arbitrary.  We assume that if any of the Set
    // methods executes the validation check, they all will, and thus we only need to test one of
    // them to ensure that the validation check happens and has the expected behavior.
    assertNodeRemovedFromGraphErrorMessage(
        assertThrows(IllegalStateException.class, n1AdjacentNodes::size));

//go:generate msgp -file $GOFILE

const (
	// beta is the weight used to calculate exponential moving average
	beta = 0.1 // Number of averages considered = 1/(1-beta)
)

// rateMeasurement captures the transfer details for one bucket/target
//msgp:ignore rateMeasurement

type rateMeasurement struct {
	lock                 sync.Mutex
	bytesSinceLastWindow uint64    // Total bytes since last window was processed

  }

  /*
   * TODO: b/315526394 - Skip the Builder entirely for the of(...) methods, since we don't need to
   * worry that we might trigger the fallback to the JDK-backed implementation? (The varargs one
   * _could_, so we could keep it as it is. Or we could convince ourselves that hash flooding is
   * unlikely in practice there, too.)
   */

  /**

        String name = "TESTFLAGS       ";
        System.arraycopy(name.getBytes("US-ASCII"), 0, src, srcIndex + 1, 16);
        src[srcIndex + 16] = 0x00; // hex code
        src[srcIndex + 17] = (byte) 0xFE; // All flags except one: 11111110
        // Bit 7: group (1)
        // Bits 6-5: owner node type (11 = 3)
        // Bit 4: being deleted (1)
        // Bit 3: in conflict (1)
        // Bit 2: active (1)
        // Bit 1: permanent (1)

        when(config.isIpcSigningEnforced()).thenReturn(true);
        when(creds.isAnonymous()).thenReturn(true);
        assertFalse(ipc.shouldForceSigning());

        // Verify interactions sequence for one call
        InOrder inOrder = inOrder(config, creds);
        ipc = locator("smb://server/IPC$/");
        ipc.shouldForceSigning();
        inOrder.verify(config, atLeastOnce()).isIpcSigningEnforced();

      .isGreaterThan(message.length.toLong()) // Not compressed.
    assertThat(client.processNextFrame()).isTrue()
    client.listener.assertTextMessage(message)
  }

  /** One peer's streams, listener, and web socket in the test.  */
  private class TestStreams(
    private val taskFaker: TaskFaker,
    private val delegate: Socket,
    private val client: Boolean,
  ) : BufferedSocket {

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *

	if extractedExpect != expectedExpect {
		t.Errorf("expect header incorrect value: expected `%s`, got `%s`", expectedExpect, extractedExpect)
	}

	// case where the headers don't contain the one of the signed header in the signed headers list.
	signedHeaders = append(signedHeaders, "X-Amz-Credential")
	// expected to fail with `ErrUnsignedHeaders`.
	_, errCode = extractSignedHeaders(signedHeaders, r)