setTreeIdMethod.invoke(response, 12345);

        // When
        int tid = response.getTid();

        // Then
        assertEquals(12345, tid);
    }

    @Test
    @DisplayName("Should validate TID correctly")
    void testIsValidTid() throws Exception {
        // Test invalid TID (-1)
        Method setTreeIdMethod = ServerMessageBlock2.class.getDeclaredMethod("setTreeId", int.class);

	encrypt.SseEncryptionContext: true,
	encrypt.SseCustomerAlgorithm: true,
	encrypt.SseCustomerKey:       true,
	encrypt.SseCustomerKeyMD5:    true,
}

// checkPostPolicy - apply policy conditions and validate input values.
// Note that content-length-range is checked in the API handler function PostPolicyBucketHandler.
// formValues is the already-canonicalized form values from the POST request.

		return s.Delete(ctx, volume, path, DeleteOptions{
			Recursive: false,
			Immediate: false,
		})
	}

	volumeDir, err := s.getVolDir(volume)
	if err != nil {
		return err
	}

	// Validate file path length, before reading.
	filePath := pathJoin(volumeDir, path)
	if err = checkPathLength(filePath); err != nil {
		return err
	}

	var legacyJSON bool

	for i := range parts {
		if errs[i] == nil {
			if parts[i].Name == objectName {
				t.Errorf("path traversal allowed to allow writing to minioMetaBucket: %s", instanceType)
			}
		}
	}
}

// Tests validate bucket name.
func TestIsValidBucketName(t *testing.T) {
	testCases := []struct {
		bucketName string
		shouldPass bool
	}{
		// cases which should pass the test.
		// passing in valid bucket names.

	// Setup and capture test results for directory with files and symlink.
	testResults = append(testResults, setupTestReadDirSymlink(t)...)

	// Remove all dirs once tests are over.
	defer teardown(testResults)

	// Validate all the results.
	for _, r := range testResults {
		if entries, err := readDir(r.dir); err != nil {
			t.Fatal("failed to run test.", err)
		} else {
			// Keep entries sorted for easier comparison.

        when(otherContext.getConfig()).thenReturn(otherConfig);
        assertFalse(response.canReuse(otherContext, false));
    }

    @Test
    @DisplayName("Should validate response correctly")
    void testIsValid() throws Exception {
        // Setup valid response
        setResponseAsReceived(response);
        setPrivateField(response, "dialectRevision", 0x0311);

          <name>type</name>
          <version>1.0.0+</version>
          <type>String</type>
          <required>true</required>
          <description>
            The Java type for this parameter. This is used to validate the result of any expressions used to calculate
            the value which should be injected into the Mojo for this parameter.
          </description>
        </field>
        <field>
          <name>required</name>

You declare the "shape" of the data as classes with attributes.

And each attribute has a type.

Then you create an instance of that class with some values and it will validate the values, convert them to the appropriate type (if that's the case) and give you an object with all the data.

And you get all the editor support with that resulting object.

An example from the official Pydantic docs:

	if err = json.Unmarshal(reqBytes, &updateReq); err != nil {
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErrWithErr(ErrAdminConfigBadJSON, err), r.URL)
		return
	}

	if err := updateReq.Validate(); err != nil {
		// Since this validation would happen client side as well, we only send
		// a generic error message here.
		writeErrorResponseJSON(ctx, w, errorCodes.ToAPIErr(ErrAdminResourceInvalidArgument), r.URL)

   *
   * @since 12.0
   */
  void putAll(Map<? extends K, ? extends V> m);

  /** Discards any cached value for key {@code key}. */
  void invalidate(@CompatibleWith("K") Object key);

  /**
   * Discards any cached values for keys {@code keys}.
   *
   * @since 11.0
   */
  // For discussion of <? extends Object>, see getAllPresent.