}
	return name
}

// getHandlerName returns the name of the handler function. It takes the type
// name as a string to clean up the name retrieved via reflection. This function
// only works correctly when the type is present in the cmd package.
func getHandlerName(f http.HandlerFunc, cmdType string) string {
	name := runtime.FuncForPC(reflect.ValueOf(f).Pointer()).Name()

        assertNotNull(info);
        assertTrue(info.toString().contains("endOfFile=" + endOfFile));
    }

    @Test
    @DisplayName("Test getFileInformationLevel returns correct value")
    void testGetFileInformationLevel() {
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfo.getFileInformationLevel());

        // Test with parameterized constructor

     * 10^floor(log10(x)).
     */

    if (approxCmp > 0) {
      /*
       * The code is written so that even completely incorrect approximations will still yield the
       * correct answer eventually, but in practice this branch should almost never be entered, and
       * even then the loop should not run more than once.
       */
      do {
        approxLog10--;

        byte[] buf = new byte[length];
        Arrays.fill(buf, (byte) 0xFF);
        return buf;
    }

    @Test
    @DisplayName("constructor initialises command and parameters correctly")
    void testConstructorInitialisesFields() throws Exception {
        int level = 42;
        Trans2QueryFSInformation cmd = new Trans2QueryFSInformation(level);

# Separate OpenAPI Schemas for Input and Output or Not { #separate-openapi-schemas-for-input-and-output-or-not }

When using **Pydantic v2**, the generated OpenAPI is a bit more exact and **correct** than before. 😎

In fact, in some cases, it will even have **two JSON Schemas** in OpenAPI for the same Pydantic model, for input and output, depending on if they have **default values**.

Let's see how that works and how to change it if you need to do that.

   * themselves their proper values under GWT, since GWT's EnumMap does need the Class instance.
   *
   * Note that sometimes these fields *do* have correct values under J2CL: They will if the caller
   * calls `create(Foo.class)`, rather than `create(map)`. That's fine; we just shouldn't rely on
   * it.
   */
  transient Class<K> keyTypeOrObjectUnderJ2cl;

        }
        // We reschedule ourselves with a lock held for two reasons. 1. we want to make sure that
        // cancel calls cancel on the correct future. 2. we want to make sure that the assignment
        // to currentFuture doesn't race with itself so that currentFuture is assigned in the
        // correct order.
        Throwable scheduleFailure = null;
        Cancellable toReturn;
        lock.lock();
        try {

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

        @Test
        @DisplayName("Should handle different buffer positions correctly")
        void testReadBytesWireFormatDifferentPositions() throws SMBProtocolDecodingException {
            byte[] buffer = new byte[1024];

            // Test at different positions

    tester.testAllPublicInstanceMethods(HostSpecifier.fromValid("google.com"));
  }

  private void assertGood(String spec) throws ParseException {
    // Throws exception if not working correctly
    HostSpecifier unused = HostSpecifier.fromValid(spec);
    unused = HostSpecifier.from(spec);
    assertTrue(HostSpecifier.isValid(spec));
  }

  private void assertBad(String spec) {
    try {

        // Test constructor initialization with proper expectations
        String pipeName = "\\\\pipe\\testPipe";
        TransWaitNamedPipe pipe = new TransWaitNamedPipe(pipeName);

        // Verify the name is set correctly
        assertEquals(pipeName, pipe.name);

        // Command should be SMB_COM_TRANSACTION
        assertEquals(ServerMessageBlock.SMB_COM_TRANSACTION, pipe.command);