* @return the number of bytes added for alignment
     */
    public int align(final int boundary, final byte value) {
        final int n = align(boundary);
        int i = n;
        while (i > 0) {
            this.buf[this.index - i] = value;
            i--;
        }
        return n;
    }

    /**
     * Writes an octet array to the buffer.
     *

  override fun addEventListener(eventListener: EventListener) {
    // Atomically replace the current eventListener with a composite one.
    do {
      val previous = this.eventListener
    } while (!eventListenerUpdater.compareAndSet(this, previous, previous + eventListener))
  }

  override fun <T : Any> tag(type: KClass<T>): T? = type.java.cast(tags.get()[type])

        } else {
            bufferSize = DEFAULT_BUF_SIZE;
        }
        char[] buf = new char[bufferSize];
        int size = 0;
        int len;
        try {
            while ((len = reader.read(buf, size, bufferSize - size)) != -1) {
                size += len;
                if (size == bufferSize) {
                    // Enforce MAX_BUF_SIZE to prevent unbounded memory growth

                if (next > 0) {
                    createContextStart += next;
                }
                bufferIndex = Math.max(bufferIndex, cci);
            } while (next > 0);
            this.createContexts = contexts.toArray(new CreateContextResponse[0]);
        }

        if (log.isDebugEnabled()) {

        @Test
        @DisplayName("Should calculate size correctly")
        void testSizeCalculation() {
            // Note: The size() method in EncryptionNegotiateContext returns 4 as base,
            // while encode() only writes 2 bytes for the count field.
            // This appears to be an implementation inconsistency.
            context = new EncryptionNegotiateContext(mockConfig, new int[3]);

        // When - test chain navigation and properties
        CommonServerMessageBlockResponse current = response1;
        int count = 0;
        boolean hasAsync = false;

        while (current != null) {
            count++;
            if (current.isAsync()) {
                hasAsync = true;
            }
            current = current.getNextResponse();
        }

        // Then

work stoppage, computer failure or malfunction, or any and all other 
commercial damages or losses), even if such Contributor has been advised of 
the possibility of such damages. 

9. Accepting Warranty or Additional Liability. While redistributing the Work 
or Derivative Works thereof, You may choose to offer, and charge a fee for, 
acceptance of support, warranty, indemnity, or other liability obligations 

     */
    protected String buildThrowableMessage(final Throwable t) {
        final StringBuilder buf = new StringBuilder(100);
        Throwable current = t;
        while (current != null) {
            buf.append(current.getLocalizedMessage()).append(' ');
            current = current.getCause();
        }
        return buf.toString();
    }

    /**

String escaped = JsonUtil.escape("Hello \"World\" with special chars");
String unescaped = JsonUtil.unescape(escaped);

// Text tokenization
Tokenizer tokenizer = new Tokenizer("field1,field2,field3", ",");
while (tokenizer.hasMoreTokens()) {
    String token = tokenizer.nextToken();
    // Process each token
}

// Decimal formatting
DecimalFormat format = DecimalFormatUtil.getDecimalFormat("###,###.00");
```

      other commercial damages or losses), even if such Contributor
      has been advised of the possibility of such damages.

   9. Accepting Warranty or Additional Liability. While redistributing
      the Work or Derivative Works thereof, You may choose to offer,
      and charge a fee for, acceptance of support, warranty, indemnity,
      or other liability obligations and/or rights consistent with this