t.Fatalf("Failed to initialize KMS: %v", err)
	}

	for i, test := range decryptKeyTests {
		dataKey, err := base64.StdEncoding.DecodeString(test.Plaintext)
		if err != nil {
			t.Fatalf("Test %d: failed to decode plaintext key: %v", i, err)
		}
		plaintext, err := KMS.Decrypt(t.Context(), &DecryptRequest{
			Name:           test.KeyID,
			Ciphertext:     []byte(test.Ciphertext),
			AssociatedData: test.Context,
		})

                    final String key = urlCodec.decode(pair.substring(0, pos), enc);
                    List<String> list = paramListMap.get(key);
                    if (list == null) {
                        list = new ArrayList<>();
                        paramListMap.put(key, list);
                    }
                    if (pos + 1 < pair.length()) {
                        list.add(urlCodec.decode(pair.substring(pos + 1), enc));

        // Test decode method
        byte[] buffer = new byte[512];
        int bufferIndex = 0;
        int expectedDecodeLength = 128;
        when(response.decode(buffer, bufferIndex)).thenReturn(expectedDecodeLength);
        assertEquals(expectedDecodeLength, response.decode(buffer, bufferIndex));

        // Test encode method
        byte[] dst = new byte[512];

        assertEquals(8, result); // Structure size (2) + offset (2) + length (4)
        assertNotNull(response.getResults());
        // Bug in implementation: when bufferLength is 0, it still tries to decode at least once
        assertEquals(1, response.getResults().length); // Due to implementation bug
    }

    @Test
    @DisplayName("Test readBytesWireFormat with invalid structure size throws exception")

	} else if len(jk.Keys) != 3 {
		t.Fatalf("Expected 3 keys, got %d", len(jk.Keys))
	}

	var kids []string
	for ii, jks := range jk.Keys {
		_, err := jks.DecodePublicKey()
		if err != nil {
			t.Fatalf("Failed to decode key %d: %v", ii, err)
		}
		kids = append(kids, jks.Kid)
	}
	if len(kids) != 3 {
		t.Fatalf("Failed to find the expected number of kids: 3, got %d", len(kids))
	}
}

// A.1 - Example public keys

    }

    /**
     * Gets the lease epoch from the V2 response
     * @return the epoch
     */
    public int getEpoch() {
        return epoch;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        int start = bufferIndex;

        if (len < 52) {

      }
      return result
    }

    /**
     * Checks if `expected` and `observed` are equal when viewed as a set and headers are
     * deduped.
     *
     * TODO: See if duped headers should be preserved on decode and verify.
     */
    private fun assertSetEquals(
      message: String,
      expected: List<Header>,
      observed: List<Header>,
    ) {
      assertThat(LinkedHashSet(observed), message)

      if (dot < limit) {
        result.writeByte('.'.code)
        pos = dot + 1
      } else {
        break
      }
    }

    return result.readUtf8()
  }

  /**
   * Converts a single label from Punycode to Unicode.
   *
   * @return true if the range of [string] from [pos] to [limit] was valid and decoded successfully.
   *     Otherwise, the decode failed.
   */
  private fun decodeLabel(

        idx += 4;

        return data;
    }

    @Override
    public int encode(byte[] dst, int dstIndex) {
        byte[] data = getData();
        System.arraycopy(data, 0, dst, dstIndex, data.length);
        return data.length;
    }

    @Override
    public int decode(byte[] buffer, int bufferIndex, int len) throws SMBProtocolDecodingException {
        if (len < 20) {

     *
     * @return the appropriate decodable object for the control code, or null if not recognized
     */
    protected Decodable createInputDecodable() {
        return null;
    }

    /**
     * Gets the output data decoded as the specified response type.
     *
     * @param <T> the type of the decoded response data