assertTrue("contains(present) should return true", collection.contains(e0()));
  }

  public void testContains_no() {
    assertFalse("contains(notPresent) should return false", collection.contains(e3()));
  }

  @CollectionFeature.Require(ALLOWS_NULL_QUERIES)
  public void testContains_nullNotContainedButQueriesSupported() {
    assertFalse("contains(null) should return false", collection.contains(null));
  }

In this case, you could want to document how that external API *should* look like. What *path operation* it should have, what body it should expect, what response it should return, etc.

## An app with callbacks { #an-app-with-callbacks }

Let's see all this with an example.

Imagine you develop an app that allows creating invoices.

    /**
     * Gets the external profiles that should be considered for model building.
     *
     * @return The external profiles that should be considered for model building, never {@code null}.
     */
    List<Profile> getProfiles();

    /**
     * Sets the external profiles that should be considered for model building.
     *
     * @param profiles The external profiles that should be considered for model building, may be {@code null}.

            assertTrue(result.contains("    <build>"), "Build element should be properly indented");
            assertTrue(result.contains("        <plugins>"), "Plugins element should be properly indented");
            assertTrue(result.contains("            <plugin>"), "Plugin element should be properly indented");
        }

        @Test
        @DisplayName("should format pluginManagement with proper indentation when added")

		t.Fatalf("Should find 1 tags after Delete")
	}

	if DB.Model(&blog).Association("Tags").Count() != 1 {
		t.Fatalf("Blog should has three tags after Delete")
	}

	DB.Model(&blog).Association("Tags").Delete(tag3)
	var tags4 []Tag
	DB.Model(&blog).Association("Tags").Find(&tags4)
	if !compareTags(tags4, []string{"tag6"}) {
		t.Fatalf("Tag should not be deleted when Delete with a unrelated tag")

		t.Errorf("name should be groupby, but got %v, total should be 60, but got %v", name, total)
	}

	if err := DB.Model(&User{}).Select("name, sum(age) as total").Where("name LIKE ?", "groupby%").Group("name").Having("name = ?", "groupby1").Row().Scan(&name, &total); err != nil {
		t.Errorf("no error should happen, but got %v", err)
	}

	if name != "groupby1" || total != 660 {

                    Arguments.of(null, false, null, false, "Should disable plugins when --plugins=false"),
                    Arguments.of(null, null, "4.1.0", false, "Should disable plugins when only --model-version is set"),
                    Arguments.of(false, null, null, false, "Should disable plugins when --all=false"),
                    Arguments.of(null, null, null, true, "Should enable plugins by default when no options specified"));
        }

    }

    @Test
    @DisplayName("should handle null terminal gracefully")
    void shouldHandleNullTerminal() {
        // Should fall back to system default charset
        for (ConsoleIcon icon : ConsoleIcon.values()) {
            String result = icon.getIcon(null);
            assertNotNull(result, "Icon result should not be null for " + icon);

		t.Errorf("Hamster's preferred toy count should be 1")
	}

	if DB.Model(&hamster2).Association("OtherToy").Count() != 1 {
		t.Errorf("Hamster's other toy count should be 1")
	}

	// Query
	hamsterToy := Toy{}
	DB.Model(&hamster).Association("PreferredToy").Find(&hamsterToy)
	if hamsterToy.Name != hamster.PreferredToy.Name {
		t.Errorf("Should find has one polymorphic association")
	}

	hamsterToy = Toy{}

        @DisplayName("should validate supported model versions")
        void shouldValidateSupportedModelVersions(String version) {
            assertTrue(ModelVersionUtils.isValidModelVersion(version));
        }

        @ParameterizedTest
        @ValueSource(strings = {"3.0.0", "5.0.0", "2.0.0", "6.0.0"})
        @DisplayName("should reject unsupported model versions")