}
  }

  private final boolean interruptible;
  private Monitor monitor;
  private final TearDownStack tearDownStack = new TearDownStack();
  private TestThread<Monitor> thread1;
  private TestThread<Monitor> thread2;

  protected MonitorTestCase(boolean interruptible) {
    this.interruptible = interruptible;
  }

  @Override
  protected final void setUp() throws Exception {

    }

    // Instance fields
    private final ErrorCode errorCode;
    private final RetryPolicy retryPolicy;
    private final Map<String, Object> context;
    private final long operationStartTime;
    private final String operationName;
    private final int attemptNumber;
    private final long ntStatus;
    private final String serverMessage;
    private final String originalMessage;

    /**

    protected static final Class<?> suppressUnusedImportLocalDateTime = LocalDateTime.class;

    // ===================================================================================
    //                                                                           Singleton
    //                                                                           =========
    private static final UserDbm _instance = new UserDbm();

    private static final Logger log = LoggerFactory.getLogger(DirFileEntryEnumIterator1.class);
    private static final int FIND_OVERHEAD = 100; // plenty enough

    private Trans2FindNext2 nextRequest;
    private Trans2FindFirst2Response response;

    public DirFileEntryEnumIterator1(final SmbTreeHandleImpl th, final SmbResource parent, final String wildcard,

    @Override
    protected int writeBytesWireFormat(final byte[] dst, int dstIndex) {
        final int start = dstIndex;
        if (this.unlocks != null) {
            for (final LockingAndXRange lockingAndXRange : this.unlocks) {
                dstIndex += lockingAndXRange.encode(dst, dstIndex);
            }
        }
        if (this.locks != null) {
            for (final LockingAndXRange lockingAndXRange : this.locks) {

     * @param max
     *            may be null for open end
     * @return range of versions
     */
    public static Set<DialectVersion> range(final DialectVersion min, final DialectVersion max) {
        final EnumSet<DialectVersion> vers = EnumSet.noneOf(DialectVersion.class);
        for (final DialectVersion ver : values()) {

            if ((min != null && !ver.atLeast(min)) || (max != null && !ver.atMost(max))) {
                continue;

     */
    public static PrunedTag[] parse(final String value) {
        return split(value, ",").get(stream -> stream.filter(StringUtil::isNotBlank).map(v -> {
            final Pattern pattern = Pattern.compile("(\\w+)(\\[[^\\]]+\\])?(\\.[\\w\\-]+)?(#[\\w\\-]+)?");
            final Matcher matcher = pattern.matcher(v.trim());
            if (matcher.matches()) {
                final PrunedTag tag = new PrunedTag(matcher.group(1));

            "RuntimeException while executing runnable " + runnable + " with executor " + executor,
            e);
      }
    }

    private static final class RunnableExecutorPair {
      final Runnable runnable;
      final Executor executor;
      @Nullable final RunnableExecutorPair next;

      RunnableExecutorPair(Runnable runnable, Executor executor, RunnableExecutorPair next) {
        this.runnable = runnable;

        return true;
    }

    @Test
    public void test_write_noConfig() throws Exception {
        final FessConfig fessConfig = createFessConfigWithResponseHeaders("");
        FessActionAdjustmentProvider provider = new FessActionAdjustmentProvider(fessConfig);
        final Map<String, String> headerMap = new HashMap<>();
        provider.adjustActionResponseHeaders("text/plain", (k, v) -> headerMap.put(k, v));

    }

    @Override
    protected int writeParameterWordsWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int writeBytesWireFormat(final byte[] dst, final int dstIndex) {
        return 0;
    }

    @Override
    protected int readParameterWordsWireFormat(final byte[] buffer, int bufferIndex) {
        if (this.wordCount == 0) {
            return 0;