}

        public void setTestResponse(TestServerMessageBlock2Response response) {
            this.testResponse = response;
        }

        public void setTestSize(int size) {
            this.testSize = size;
        }

        public void setTestLength(int length) {
            this.testEncodedLength = length;
        }

        @Override

     * The name of the plugin to delete.
     * Required field with maximum length of 100 characters.
     */
    @Required
    @Size(max = 100)
    public String name;

    /**
     * The version of the plugin to delete.
     * Optional field with maximum length of 100 characters.
     */
    @Size(max = 100)
    public String version;

import jakarta.validation.constraints.Size;

/**
 * The edit form for Related Query.
 * This form extends CreateForm and adds fields necessary for editing existing related query entries.
 */
public class EditForm extends CreateForm {

    /** Unique identifier for the related query entry */
    @Required
    @Size(max = 1000)
    public String id;

     */
    public QueryNetworkInterfaceInfoRequest() {
        // No input data required for this IOCTL
    }

    /**
     * Get the size of this request (always 0)
     *
     * @return size in bytes
     */
    public int size() {
        return 0;
    }

    /**
     * Encode this request (no-op since there's no data)
     *
     * @param dst destination buffer

    List<Object> values = new ArrayList<>(map.values());
    assertEquals(2 * entries.size(), alternatingKeysAndValues.length);
    assertEquals(2 * keys.size(), alternatingKeysAndValues.length);
    assertEquals(2 * values.size(), alternatingKeysAndValues.length);
    for (int i = 0; i < map.size(); i++) {
      Object expectedKey = alternatingKeysAndValues[2 * i];

        assertTrue(exceptions.isEmpty());
        assertEquals(threadCount * objectsPerThread, createdComponents.size());

        // Check all components are unique (for prototype)
        for (int i = 0; i < createdComponents.size(); i++) {
            for (int j = i + 1; j < createdComponents.size(); j++) {
                assertNotSame(createdComponents.get(i), createdComponents.get(j));
            }
        }
    }

      for (int j = 0; j < 2; j++) {
        nonnegInt[i][j] = randomNonNegativeBigInteger(Integer.SIZE - 2).intValue();
        nonnegLong[i][j] = randomNonNegativeBigInteger(Long.SIZE - 2).longValue();
      }
      do {
        for (int j = 0; j < 2; j++) {
          intsToAdd[i][j] = randomBigInteger(Integer.SIZE - 2).intValue();
        }
      } while (!Impl.GUAVA.noAddOverflow(intsToAdd[i][0], intsToAdd[i][1]));

    List<E> expectedList = copyToList(expectedCollection);
    // Avoid expectEquals() here to delay reason manufacture until necessary.
    if (getList().size() != expectedList.size()) {
      fail("size mismatch: " + reportContext(expectedList));
    }
    for (int i = 0; i < expectedList.size(); i++) {
      E expected = expectedList.get(i);
      E actual = getList().get(i);

    String data = "Test Using Larger Than Block-Size Key - Hash Key First";

    checkSha1("aa4ae5e15272d00e95705637ce8a3b55ed402112", key, data);
  }

  public void testRfc2202_hmacSha1_case7() {
    byte[] key = fillByteArray(80, 0xaa);
    String data = "Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data";

    checkSha1("e8e99d0f45237d786d6bbaa7965c7808bbff1a91", key, data);

	var buffer []byte
	switch size := data.Size(); {
	case size == 0:
		buffer = make([]byte, 1) // Allocate at least a byte to reach EOF
	case size >= fi.Erasure.BlockSize || size == -1:
		buffer = globalBytePoolCap.Load().Get()
		defer globalBytePoolCap.Load().Put(buffer)
	case size < fi.Erasure.BlockSize: