public void testAddAllAtIndex_supportedNothing() {
    assertFalse("addAll(n, nothing) should return false", getList().addAll(0, emptyCollection()));
    expectUnchanged();
  }

  @ListFeature.Require(absent = SUPPORTS_ADD_WITH_INDEX)
  public void testAddAllAtIndex_unsupportedNothing() {
    try {
      assertFalse(
          "addAll(n, nothing) should return false or throw",
          getList().addAll(0, emptyCollection()));

  public void testGet_yes() {
    assertEquals("get(present) should return the associated value", v0(), get(k0()));
  }

  public void testGet_no() {
    assertNull("get(notPresent) should return null", get(k3()));
  }

  @MapFeature.Require(ALLOWS_NULL_KEY_QUERIES)
  public void testGet_nullNotContainedButAllowed() {
    assertNull("get(null) should return null", get(null));
  }

        // Then
        assertTrue(smb2Only, "Should delegate SMB2 only negotiation");
        assertFalse(secureNegotiate, "Should delegate secure negotiate requirement");
        assertTrue(ntlmTargetName, "Should delegate NTLM target name setting");
        assertFalse(port139Failover, "Should delegate port 139 failover setting");
        assertTrue(dfsStrictView, "Should delegate DFS strict view setting");

            assertNotNull(str, "toString should not return null");
            assertTrue(str.contains("SmbComTreeConnectAndXResponse"), "Should contain class name");
            assertTrue(str.contains("supportSearchBits=true"), "Should contain search bits flag");
            assertTrue(str.contains("shareIsInDfs=true"), "Should contain DFS flag");
            assertTrue(str.contains("service=IPC"), "Should contain service");

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.

        assertNotNull(request);
        // The request should be properly created - we can't easily verify headers without mocking framework
    }

    public void test_post() {
        setupMockConfig("localhost:9200", "", "");

        curlHelper.init();
        CurlRequest request = curlHelper.post("/test");

        assertNotNull(request);
        // The request should be properly created
    }

    public void test_put() {

	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Model(&User{}).Where("sdsd.zaaa = ?", "sd;;;aa").Pluck("aaa", &columns).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	if DB.Where("sdsd.zaaa = ?", "sd;;;aa").Find(&User{}).Error == nil {
		t.Errorf("Should got error with invalid SQL")
	}

	var count1, count2 int64

    void testHasNextAlwaysReturnsFalse() {
        // When & Then
        assertFalse(emptyIterator.hasNext(), "hasNext should return false");
        assertFalse(emptyIterator.hasNext(), "hasNext should consistently return false");
        assertFalse(emptyIterator.hasNext(), "hasNext should always return false on repeated calls");
    }

    @Test
    @DisplayName("next should return null")

    class ConstructorTests {

        @Test
        @DisplayName("Should create handler with default constructor")
        void testDefaultConstructor() {
            // When
            Handler testHandler = new Handler();

            // Then
            assertNotNull(testHandler);
        }

        @Test
        @DisplayName("Should extend jcifs.smb1.http.Handler")
        void testInheritance() {

            request.writeBytesWireFormat(buffer, i * 10);
        }

        // Then - all should have same structure size
        for (int i = 0; i < 10; i++) {
            assertEquals(4, SMBUtil.readInt2(buffer, i * 10));
        }
    }

    @Test
    @DisplayName("Should handle null configuration gracefully in response creation")
    void testCreateResponseWithNullConfig() {
        // Given