}

    @Test
    public void test_constructor_withNullType() {
        // Test constructor with null type
        String type = null;
        String message = "Token validation failed";
        InvalidAccessTokenException exception = new InvalidAccessTokenException(type, message);

        assertNull(exception.getType());
        assertEquals(message, exception.getMessage());

                logger.info("Created user: {}", entity.getName());
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to create user: {}", form.name, e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

	internodeSentBytesTotal   MetricName = "sent_bytes_total"
	internodeRecvBytesTotal   MetricName = "recv_bytes_total"
)

var (
	internodeErrorsTotalMD = NewCounterMD(internodeErrorsTotal,
		"Total number of failed internode calls")
	internodeDialedErrorsTotalMD = NewCounterMD(internodeDialErrorsTotal,
		"Total number of internode TCP dial timeouts and errors")
	internodeDialAvgTimeNanosMD = NewGaugeMD(internodeDialAvgTimeNanos,

        }

        final TimeoutTask timeoutTask = createTimeoutTask();
        try {
            executeSuggestCreator();
        } catch (final Exception e) {
            logger.warn("Failed to create suggest data.", e);
            resultBuf.append(e.getMessage()).append("\n");
        } finally {
            if (timeoutTask != null && !timeoutTask.isCanceled()) {
                timeoutTask.cancel();

                    httpEntity = response.getEntity();
                    consumer.accept(response, httpEntity);
                } catch (final Exception e) {
                    logger.warn("Failed to authenticate with form-based authentication: scheme={}, url={}", scheme, request.getRequestUri(),
                            e);
                } finally {
                    try {

                    updateMethod.setAccessible(true);
                    updateMethod.invoke(transport, testData);
                } catch (Exception e) {
                    fail("Thread failed: " + e.getMessage());
                } finally {
                    doneLatch.countDown();
                }
            });
        }

        // Start all threads at once

        // Mock transport.connect() to succeed
        doNothing().when(transport).connect();

        // Simulate failed tree connect
        doThrow(new SmbException("Connection failed")).when(session).send(any(ServerMessageBlock.class), any(ServerMessageBlock.class));

        assertThrows(SmbException.class, () -> tree.treeConnect(null, null));

        when(delegate.hasNext()).thenReturn(false);
        doThrow(new CIFSException("Close failed")).when(delegate).close();

        TestIterator iterator = new TestIterator(null);

        CIFSException ex = assertThrows(CIFSException.class, iterator::close);
        assertEquals("Close failed", ex.getMessage());
    }

    @Test
    @DisplayName("Remove delegates to underlying iterator")

            try {
                fileConfigService.store(entity);
                saveInfo(messages -> messages.addSuccessCrudCreateCrudTable(GLOBAL));
            } catch (final Exception e) {
                logger.warn("Failed to process a request.", e);
                throwValidationError(messages -> messages.addErrorsCrudFailedToCreateCrudTable(GLOBAL, buildThrowableMessage(e)),
                        this::asEditHtml);
            }

    client.newCall(Request(url)).enqueue(
      object : Callback {
        override fun onFailure(
          call: Call,
          e: IOException,
        ) {
          println("failed: $e")
        }

        override fun onResponse(
          call: Call,
          response: Response,
        ) {
          println("response: ${response.code}")
          response.close()
        }