private static final Logger log = LoggerFactory.getLogger(LeaseManager.class);

    private final ConcurrentHashMap<Smb2LeaseKey, LeaseEntry> leases;
    private final ConcurrentHashMap<String, Smb2LeaseKey> pathToLease;
    private final ConcurrentHashMap<String, WeakReference<SmbFile>> fileCache;
    private final ReadWriteLock lock;
    private final CIFSContext context;
    private final ScheduledExecutorService cleanupExecutor;

        // Default constructor
    }

    /** Dictionary identifier */
    @Required
    public String dictId;

    /** CRUD operation mode (CREATE, EDIT, etc.) */
    @ValidateTypeFailure
    public Integer crudMode;

    /** Word or phrase to be protected from analysis */
    @Required
    @Size(max = 1000)
    public String input;

    /**

     */
    public ExecutionTimeoutException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new exception with the specified detail message.
     *
     * @param message the detail message.
     */
    public ExecutionTimeoutException(final String message) {
        super(message);
    }

    /**

     * @param cause the cause of the exception
     */
    public SitemapsException(final String message, final Throwable cause) {
        super(message, cause);
    }

    /**
     * Constructs a new SitemapsException with the specified detail message.
     * @param message the detail message
     */
    public SitemapsException(final String message) {
        super(message);
    }

    /**

    /**
     * The bad word to be filtered from search suggestions.
     */
    @Required
    @Pattern(regexp = "[^\\s]+")
    public String suggestWord;

    /**
     * The username of the user who created this bad word entry.
     */
    @Size(max = 1000)
    public String createdBy;

    /**
     * The timestamp when this bad word entry was created.
     */
    @ValidateTypeFailure
    public Long createdTime;

    }

    /**
     * Name of the crawling configuration.
     */
    @Required
    @Size(max = 200)
    public String crawlingConfigName;

    /**
     * Path or URL to be crawled by this configuration.
     */
    @Required
    @Size(max = 1000)
    public String crawlingConfigPath;

    /**
     * Maximum depth for crawling (how many levels deep to follow links).
     */
    @Min(value = 0)

     * @param password The new password.
     * @return True if the password was successfully changed, false otherwise.
     */
    boolean changePassword(String username, String password);

    /**
     * Loads user information from the authentication chain.
     * @param user The user template containing search criteria.
     * @return The loaded user, or null if not found.
     */

        DEPENDENCIES,
        CHILDREN
    }

    /**
     * The phase name.
     */
    String phase();

    /**
     * The type of this pointer.
     */
    Type type();

    /**
     * The scope for dependencies, only if {@code type() == Type.Dependencies}.
     */
    String scope() default "";

	}
}

func TestPsqlTableNameValidation(t *testing.T) {
	validTables := []string{"táblë", "table", "TableName", "\"Table name\"", "\"✅✅\"", "table$one", "\"táblë\""}
	invalidTables := []string{"table name", "table \"name\"", "✅✅", "$table$"}

	for _, name := range validTables {
		if err := validatePsqlTableName(name); err != nil {
			t.Errorf("Should be valid: %s - %s", name, err)
		}
	}
	for _, name := range invalidTables {

		// Pop the topmost item from the stack and resume with the next one down.
		s.tr = s.tr[:len(s.tr)-1]
		tok = s.Next()
	}
	return tok
}

func (s *Stack) Text() string {
	return s.tr[len(s.tr)-1].Text()
}

func (s *Stack) File() string {
	return s.Base().Filename()
}

func (s *Stack) Base() *src.PosBase {
	return s.tr[len(s.tr)-1].Base()
}

func (s *Stack) SetBase(base *src.PosBase) {