The same way as with regular header parameters, when you have underscore characters in the parameter names, they are **automatically converted to hyphens**.

For example, if you have a header parameter `save_data` in the code, the expected HTTP header will be `save-data`, and it will show up like that in the docs.

If for some reason you need to disable this automatic conversion, you can do it as well for Pydantic models for header parameters.

    }
  }

  fun readBoolean(): Boolean {
    if (bytesLeft != 1L) throw ProtocolException("unexpected length: $bytesLeft at $this")
    return source.readByte().toInt() != 0
  }

  fun readBigInteger(): BigInteger {
    if (bytesLeft == 0L) throw ProtocolException("unexpected length: $bytesLeft at $this")
    val byteArray = source.readByteArray(bytesLeft)
    return BigInteger(byteArray)
  }

    try {
      getList().set(0, e3());
      fail("set() should throw UnsupportedOperationException or IndexOutOfBoundsException");
    } catch (UnsupportedOperationException | IndexOutOfBoundsException expected) {
    }
    expectUnchanged();
  }

  @CollectionSize.Require(absent = ZERO)
  @ListFeature.Require(SUPPORTS_SET)
  @CollectionFeature.Require(absent = ALLOWS_NULL_VALUES)

                for (i in 0..9) {
                  sink.writeByte(0)
                  sink.flush()
                  sleep(100)
                }
                fail("Expected connection to be closed")
              }
            },
          ).build(),
      )
    interruptLater(500)
    assertFailsWith<IOException> {
      call.execute()
    }
  }

  @Test

        assertEquals(3, encodedLen, "Encoded length should be equal to the specified length");

        // Verify content
        assertArrayEquals(new byte[] { 0x02, 0x03, 0x04, 0x00, 0x00 }, dest, "Encoded bytes should match the expected subset");
    }

    @Test
    void testEncodeWithOffset() {
        // Test encoding with a destination offset
        byte[] data = { 0x01, 0x02, 0x03, 0x04, 0x05 };

    try {
      getDone(future);
      fail();
    } catch (CancellationException expected) {
    }

    try {
      getDoneFromTimeoutOverload(future);
      fail();
    } catch (CancellationException expected) {
    }
  }

  private static void assertDone(AbstractFuture<Integer> future) {
    CountingRunnable listener = new CountingRunnable();

        assertTrue(actual.endsWith(expectedEnd), "toString should end with ',addrEntry=]' when addrEntry is null");
        assertTrue(actual.startsWith("NameQueryResponse["), "toString should start with expected prefix");
    }

    @Test
    void toString_shouldReturnExpectedFormat_withNonNullAddrEntry() throws NoSuchFieldException, IllegalAccessException {
        // Set 'addrEntry' with some NbtAddress objects

    Future<?> possiblyIgnoredError = threadPool.submit(new Interrupter(currentThread()));
    try {
      Queues.drain(q, ImmutableList.of(), 100, MAX_VALUE, NANOSECONDS);
      fail();
    } catch (InterruptedException expected) {
    }
  }

  public void testDrainUninterruptibly_doesNotThrow() throws Exception {
    for (BlockingQueue<Object> q : blockingQueues()) {
      testDrainUninterruptiblyDoesNotThrow(q);
    }
  }

            SMBProtocolDecodingException exception =
                    assertThrows(SMBProtocolDecodingException.class, () -> echoResponse.readBytesWireFormat(buffer, bufferIndex));

            assertEquals("Expected structureSize = 4", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 1, 2, 3, 5, 6, 100, 65535 })

	}

	var parents []ItemParent
	if err := tx.Find(&parents).Error; err != nil {
		t.Errorf("failed to find item parent, got error: %v", err)
	}
	if len(parents) != 1 {
		t.Errorf("expected %d parents, got %d", 1, len(parents))
	}

	// test delete
	if err := tx.Model(&item).Association("ItemParent").Unscoped().Delete(&parents); err != nil {
		t.Errorf("failed to delete item parent, got error: %v", err)