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

                    context.success("No inference optimizations needed");
                }
            } catch (Exception e) {
                context.failure("Failed to apply inference optimizations" + ": " + e.getMessage());
                errorPoms.add(pomPath);
            } finally {
                context.unindent();
            }
        }

        return new UpgradeResult(processedPoms, modifiedPoms, errorPoms);

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

        try {
            execJob.execute();
            fail("Should throw RuntimeException");
        } catch (RuntimeException e) {
            assertEquals("Test exception", e.getMessage());
        }
    }

    // Test concurrent modification of jvmOptions
    @Test
    public void test_jvmOptions_concurrent() throws InterruptedException {

    ImmutableMap<Object, ImmutableList<Object>> tmpMap;
    try {
      tmpMap = builder.buildOrThrow();
    } catch (IllegalArgumentException e) {
      throw (InvalidObjectException) new InvalidObjectException(e.getMessage()).initCause(e);
    }

    deserializationReplacement = new ImmutableListMultimap<>(tmpMap, tmpSize);
  }

  @GwtIncompatible
  @J2ktIncompatible
    private Object readResolve() {

                index++;
            }
            return Integer.parseInt(response.substring(index, index + 3));
        } catch (final Exception ex) {
            throw new IOException(ex.getMessage());
        }
    }

    private void doHandshake() throws IOException, GeneralSecurityException {
        connect();
        try {
            int response = parseResponseCode();

                sb.append(new String(buf, 0, n, "ISO8859_1"));
            }
            style = sb.toString();
        } catch (final IOException ioe) {
            throw new ServletException(ioe.getMessage());
        }

        enableBasic = Config.getBoolean("jcifs.smb1.http.enableBasic", false);
        insecureBasic = Config.getBoolean("jcifs.smb1.http.insecureBasic", false);

            assertTrue(cause instanceof SMBProtocolDecodingException, "Actual cause should be SMBProtocolDecodingException");
            assertEquals("Structure size is not 16", cause.getMessage(), "Should have correct error message");
        }

        @Test
        @DisplayName("Should write empty bytes for wire format")
        void testWriteBytesWireFormat() throws Exception {
            // Given

                    assertThrows(SMBProtocolDecodingException.class, () -> response.readBytesWireFormat(buffer, 0));
            assertEquals("Expected structureSize = 60", exception.getMessage());
        }

        @ParameterizedTest
        @ValueSource(ints = { 0, 10, 20, 30 })
        @DisplayName("Should correctly read from different buffer offsets")

                        doRecv(response);
                        response.received();
                    }
                }
            } catch (final Exception ex) {
                final String msg = ex.getMessage();
                final boolean timeout = ex instanceof SocketTimeoutException || msg != null && msg.equals("Read timed out");
                final boolean closed = msg != null && msg.equals("Socket closed");