private String componentName;

    /**
     * Constructor with component name.
     * @param componentName The name of the component that is not available.
     */
    public ContainerNotAvailableException(final String componentName) {
        super(componentName + " is not available.");
    }

    /**
     * Constructor with component name and cause.

import java.lang.annotation.Target;

import static java.lang.annotation.ElementType.CONSTRUCTOR;
import static java.lang.annotation.ElementType.FIELD;
import static java.lang.annotation.ElementType.METHOD;
import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Marks a dependency injection point for constructor, method, or field injection.
 * <p>

  @LazyInit @RetainedWith private transient @Nullable Converter<B, A> reverse;

  /** Constructor for use by subclasses. */
  protected Converter() {
    this(true);
  }

  /** Constructor used only by {@code LegacyConverter} to suspend automatic null-handling. */
  Converter(boolean handleNullAutomatically) {

   * underlying data structure.
   */
  public static <K extends @Nullable Object, V extends @Nullable Object>
      ArrayListMultimap<K, V> create() {
    return new ArrayListMultimap<>();
  }

  /**
   * Constructs an empty {@code ArrayListMultimap} with enough capacity to hold the specified
   * numbers of keys and values without resizing.
   *
   * <p>You may also consider the equivalent {@code

        verify(mockConfig).getTransactionBufferSize();
    }

    @Test
    @DisplayName("Test constructor with output buffer")
    void testConstructorWithOutputBuffer() {
        // This constructor doesn't use getTransactionBufferSize()
        Smb2IoctlRequest request = new Smb2IoctlRequest(mockConfig, TEST_CONTROL_CODE, TEST_FILE_ID, TEST_OUTPUT_BUFFER);

        assertNotNull(request);

 * {@link #getRootCause()}, and {@link #toString()}.
 */
@ExtendWith(MockitoExtension.class)
class SmbExceptionTest {

    /**
     * Happy path – constructor with a valid NT status code (0).
     */
    @Test
    @DisplayName("Constructor 0 – NT_STATUS_SUCCESS")
    void testConstructorWithZeroCode() {
        SmbException ex = new SmbException(0, false);
        assertEquals("NT_STATUS_SUCCESS", ex.getMessage());

    }

    private static byte B(final int i) {
        return (byte) (i & 0xFF);
    }

    private static short S(final int i) {
        return (short) (i & 0xFFFF);
    }

    /**
     * Constructs a UUID from an existing rpc.uuid_t object
     *
     * @param uuid the wrapped uuid object to copy values from
     */
    public UUID(final rpc.uuid_t uuid) {
        time_low = uuid.time_low;

    }

    @Test
    @DisplayName("Test default constructor creates valid instance")
    void testDefaultConstructor() {
        // Verify instance is created
        assertNotNull(fileInfo);
        assertEquals(FileInformation.FILE_ENDOFFILE_INFO, fileInfo.getFileInformationLevel());
    }

    @Test
    @DisplayName("Test parameterized constructor with end of file value")
    void testParameterizedConstructor() {

        testResponseBuffer = new byte[] { 0x05, 0x06, 0x07, 0x08 };
        negotiation = new SmbNegotiation(mockRequest, mockResponse, testRequestBuffer, testResponseBuffer);
    }

    @Test
    @DisplayName("Constructor should properly initialize all fields")
    void testConstructor() {
        // Verify all fields are properly initialized
        assertNotNull(negotiation);
        assertSame(mockRequest, negotiation.getRequest());

  private int position;

  /** Returns the element with the specified index. This method is called by {@link #next()}. */
  @ParametricNullness
  protected abstract E get(int index);

  /**
   * Constructs an iterator across a sequence of the given size whose initial position is 0. That
   * is, the first call to {@link #next()} will return the first element (or throw {@link
   * NoSuchElementException} if {@code size} is zero).
   *