}

        @Override
        public String toString() {
          return "starting()";
        }
      };
  private static final ListenerCallQueue.Event<Listener> RUNNING_EVENT =
      new ListenerCallQueue.Event<Listener>() {
        @Override
        public void call(Listener listener) {
          listener.running();
        }

        @Override
        public String toString() {
          return "running()";

            Versioning versioningRef = reference.getVersioning();
            if (versioning != null && versioningRef != null) {
                String lastUpdated = versioning.getLastUpdated();
                String now = versioningRef.getLastUpdated();
                if (lastUpdated != null && now != null && now.compareTo(lastUpdated) < 0) {
                    getLogger()

    void testWildcardPatterns() {
        request = new Smb2QueryDirectoryRequest(mockConfig);

        // Test various wildcard patterns
        String[] patterns = { "*", "*.txt", "test*.*", "?test?.doc" };

        for (String pattern : patterns) {
            request.setFileName(pattern);

            byte[] buffer = new byte[1024];

        Field handlersField = Handler.class.getDeclaredField("PROTOCOL_HANDLERS");
        handlersField.setAccessible(true);
        @SuppressWarnings("unchecked")
        Map<String, URLStreamHandler> handlers = (Map<String, URLStreamHandler>) handlersField.get(null);
        handlers.clear();
    }

    /**
     * Pre-populates the protocol handlers cache with mock handlers for testing.

    /**
     * Default constructor.
     */
    public AdminRoleAction() {
        super();
    }

    /** Role name for admin role operations */
    public static final String ROLE = "admin-role";

    private static final Logger logger = LogManager.getLogger(AdminRoleAction.class);

    // ===================================================================================

    @Test
    public void testValidString() throws Exception {
        validator.validateString("normal string", 100, "test");
        validator.validateString(null, 100, "test"); // Null should be allowed
        // Should pass without exception
    }

    @Test
    public void testStringTooLong() throws Exception {
        String longString = "a".repeat(300);
        assertThrows(SmbException.class, () -> {

    @DisplayName("toString() renders lower-case hex with zero-padding")
    void toString_rendersHex(byte[] input, String expected) {
        // Arrange
        SecurityBlob blob = new SecurityBlob(input);

        // Act
        String actual = blob.toString();

        // Assert
        assertEquals(expected, actual, "Hex string should match expected format");
    }

        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfoWithEof.getFileInformationLevel());

        // Test toString
        String str = fileInfoWithEof.toString();
        assertNotNull(str);
        assertTrue(str.contains("EndOfFileInformation"));
        assertTrue(str.contains("1024"));
    }

    /**

        if (error instanceof SocketTimeoutException) {
            return true;
        }

        // Some socket errors might be recoverable
        if (error instanceof SocketException) {
            String message = error.getMessage();
            if (message != null) {
                message = message.toLowerCase();
                // Connection reset, network unreachable, etc. might be temporary

	user1 := User{Name: "ScanUser1", Age: 1}
	user2 := User{Name: "ScanUser2", Age: 10}
	user3 := User{Name: "ScanUser3", Age: 20}
	DB.Save(&user1).Save(&user2).Save(&user3)

	type result struct {
		ID   uint
		Name string
		Age  int
	}

	var res result
	DB.Table("users").Select("id, name, age").Where("id = ?", user3.ID).Scan(&res)
	if res.ID != user3.ID || res.Name != user3.Name || res.Age != int(user3.Age) {