writeSecurityBuffer(type3, 52, offset, sessionKey);
            writeULong(type3, 60, flags);
            return type3;
        } catch (final IOException ex) {
            throw new IllegalStateException(ex.getMessage());
        }
    }

    @Override
    public String toString() {
        final String user = getUser();
        final String domain = getDomain();
        final String workstation = getWorkstation();

      if (!isPermitted(exception)) {
        String message =
            "Exception "
                + exception.getClass().getSimpleName()
                + " was thrown; expected "
                + getMessage();
        throw new AssertionError(message, exception);
      }
    }

    @GwtIncompatible @J2ktIncompatible private static final long serialVersionUID = 0;
  }

            IllegalArgumentException exception = assertThrows(IllegalArgumentException.class, () -> referralData.stripPathConsumed(10));
            assertEquals("Stripping more than consumed", exception.getMessage());
        }

        private void setupReferralDataWithPathConsumed(int consumed) {
            when(mockReferral.getTtl()).thenReturn(300);
            when(mockReferral.getRFlags()).thenReturn(0);

                    } catch (Exception e) {
                        throw new SMBProtocolDecodingException(
                                "Failed to decode negotiate context at position " + i + ": " + e.getMessage(), e);
                    }
                }
                ncpos += dataLen;
                if (i != negotiateContextCount - 1) {
                    int padding = pad8(ncpos);

                            // Expected if closed
                        }
                    }
                } catch (Exception e) {
                    fail("Unexpected exception: " + e.getMessage());
                } finally {
                    completeLatch.countDown();
                }
            }).start();
        }

        // Start all threads simultaneously

            result.getProblems().forEach(p -> {
                assertTrue(expectedException.isInstance(p.getException()));
                assertTrue(p.getException().getMessage().contains(partOfMessage));
            });
        }
    }

    @Test
    void testProcessPackagingAttribute() throws ProjectBuildingException {
        graphBuilder = new DefaultGraphBuilder(

                            .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);

    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

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

                logger.warn("LDAP configuration error: {}", e.getMessage(), e);
            } catch (final LdapOperationException e) {
                logger.warn("LDAP connection failed: {}", e.getMessage(), e);
            } catch (final Exception e) {
                logger.warn("Unexpected error during LDAP validation: {}", e.getMessage(), e);
            }
        }
        return isBind;
    }

    /**