LogRecord record = Iterables.getOnlyElement(logHandler.getStoredLogRecords());
    // We log failures that occur after startup
    assertThat(record.getMessage())
        .contains("Service FailRunService [FAILED] has failed in the RUNNING state");
  }

  /**
   * Tests that a ServiceManager can be fully shut down if one of its failure listeners is slow or

                            .stream();
                } catch (OpenSearchStatusException | IllegalStateException e) {
                    final String msg = e.getMessage();
                    if (StringUtil.isNotEmpty(msg) && msg.contains("index.analyze.max_token_count")) {
                        logger.warn("Failed to parse document (token count exceeded): index={}, message={}", index, msg);

                }
                
            } catch (Exception e) {
                log.debug("Reconnect attempt {} failed: {}", attempt + 1, e.getMessage());
                
                // Retry
                return attemptReconnect(file, info, attempt + 1).join();
            }
        });
    }
}
```

            } catch (final UnknownHostException ex) {
                this.uhe = ex;
            } catch (final Exception ex) {
                this.uhe = new UnknownHostException(ex.getMessage());
            } finally {
                synchronized (this.sem) {
                    this.sem.count--;
                    this.sem.notify();
                }
            }
        }

        tikaExtractor.maxUncompressionSize = 10000;
        try {
            tikaExtractor.getText(in, null);
            fail();
        } catch (final ExtractException e) {
            logger.info(e.getMessage());
        }
    }

    public void test_getTika_tar() {
        final InputStream in = ResourceUtil.getResourceAsStream("extractor/tar/test.tar");

            if (logger.isDebugEnabled()) {
                logger.warn("Malformed URI: " + attrValue, e);
            } else {
                logger.warn("Malformed URI: " + attrValue + " - " + e.getMessage());
            }
        }
    }

    /**
     * Encodes a URL using the specified character encoding.
     *
     * @param url the URL to encode
     * @param enc the character encoding to use

    private volatile boolean serviceAvailable = true;
    
    public void handleServiceUnavailable(Exception error) {
        log.warn("Witness service unavailable: {}", error.getMessage());
        serviceAvailable = false;
        
        // Schedule retry
        scheduleServiceRetry();
    }
    
    private void scheduleServiceRetry() {
        scheduler.schedule(() -> {

    // being true.
    Pattern pattern = Pattern.compile("Multiple entries with same key: four=(.*) and four=(.*)");
    assertThat(expected).hasMessageThat().matches(pattern);
    Matcher matcher = pattern.matcher(expected.getMessage());
    assertThat(matcher.matches()).isTrue();
    assertThat(matcher.group(1)).isNotEqualTo(matcher.group(2));
  }

  public void testOf() {
    assertMapEquals(ImmutableMap.of("one", 1), "one", 1);

            Relocation target, Relocation source, boolean sourceDominant, Map<Object, Object> context) {
        String src = source.getMessage();
        if (src != null) {
            if (sourceDominant || target.getMessage() == null) {
                target.setMessage(src);
                target.setLocation("message", source.getLocation("message"));
            }
        }
    }

                    }
                    try {
                        this.transport.wait();
                    } catch (InterruptedException ie) {
                        throw new SmbException(ie.getMessage(), ie);
                    }
                }

                try {
                    trans.ensureConnected();

                    /*
                     * Session Setup And X Request / Response