assertTrue(cbWithMetrics.getAverageResponseTime() > 0, "Average response time should be tracked");
            assertTrue(cbWithMetrics.getMinResponseTime() > 0, "Min response time should be tracked");
            assertTrue(cbWithMetrics.getMaxResponseTime() > 0, "Max response time should be tracked");
            assertTrue(cbWithMetrics.getP95ResponseTime() > 0, "P95 response time should be tracked");

        handle.close();
        verify(treeConnection, times(1)).release();

        // Second release -> usage 0 -> -1 triggers RuntimeCIFSException
        RuntimeCIFSException ex = assertThrows(RuntimeCIFSException.class, () -> handle.release());
        assertTrue(ex.getMessage().contains("below zero"));
        verify(treeConnection, times(1)).release(); // still only once
    }

    @Test

            assertNotNull(handle);
            // Verify that sendrecv was called with MsrpcSamrConnect4 and then MsrpcSamrConnect2
            verify(mockHandle, times(1)).sendrecv(any(MsrpcSamrConnect4.class));
            verify(mockHandle, times(1)).sendrecv(any(MsrpcSamrConnect2.class));
        }
    }

    @Test
    void testConstructor_OtherDcerpcException() throws DcerpcException, IOException {

	var objs []ObjectOpts
	curModTime := time.Date(2025, time.February, 10, 23, 0, 0, 0, time.UTC)
	for i := range 5 {
		obj := ObjectOpts{
			Name:        "obj",
			VersionID:   uuid.New().String(),
			ModTime:     curModTime.Add(time.Duration(-i) * time.Second),
			NumVersions: 5,
		}
		if i == 0 {
			obj.IsLatest = true
		} else {
			obj.SuccessorModTime = curModTime.Add(time.Duration(-i+1) * time.Second)
		}

		}
	}
	newValues["updated_at"] = time.Time{}
	newValues["active"] = false
	checkField(t, userSchema, reflectValue, newValues)

	// test valuer and other type
	age := myint(10)
	var nilTime *time.Time
	newValues2 := map[string]interface{}{
		"name":       sql.NullString{String: "valuer_and_setter_3", Valid: true},
		"id":         &sql.NullInt64{Int64: 3, Valid: true},

import static java.util.concurrent.TimeUnit.NANOSECONDS;
import static java.util.concurrent.TimeUnit.SECONDS;
import static org.junit.Assert.assertThrows;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;

import com.google.common.base.Suppliers;
import com.google.common.collect.ImmutableList;

 */
package org.apache.maven.api;

import java.time.Clock;
import java.time.Duration;
import java.time.Instant;
import java.time.ZoneId;
import java.time.ZoneOffset;

/**
 * A Clock implementation that combines monotonic timing with wall-clock time.
 * <p>
 * This class provides precise time measurements using {@link System#nanoTime()}
 * while maintaining wall-clock time information in UTC. The wall-clock time

	if d == "" {
		cfg.MaxTimeout = 30 * time.Second
	} else {
		dur, _ := time.ParseDuration(d)
		if dur < time.Second {
			cfg.MaxTimeout = 30 * time.Second
		} else {
			cfg.MaxTimeout = getMaxTimeout(dur)
		}
	}
	return cfg, err
}

func getMaxTimeout(t time.Duration) time.Duration {
	if t > time.Second {
		return t
	}
	// get default value

        InOrder inOrder = inOrder(handle, fd, tree);
        inOrder.verify(handle, times(1)).ensureOpen();
        inOrder.verify(fd, times(1)).getTree();
        inOrder.verify(tree, times(1)).send(any(Smb2IoctlRequest.class), eq(RequestParam.NO_RETRY));
        verify(fd, times(1)).close();
        verify(tree, times(1)).close();
    }

    @ParameterizedTest

            assertDoesNotThrow(mockSession::close);

            verify(mockSession, times(1)).getConfig();
            verify(mockSession, times(1)).getContext();
            verify(mockSession, times(1)).unwrap(SmbSession.class);
            verify(mockSession, times(1)).close();
        }

        @Test
        @DisplayName("Should support partial mocking scenarios")