writeLittleEndianInt(baos, 100); // size
        writeLittleEndianLong(baos, 1000); // offset way out of bounds
        byte[] pacData = baos.toByteArray();

        // This currently throws ArrayIndexOutOfBoundsException
        // but should be wrapped in PACDecodingException
        assertThrows(Exception.class, () -> new Pac(pacData, keys));
    }

    @Test
    void testZeroBufferCount() throws IOException {

            if (dstIndex < 0) {
                throw new IllegalArgumentException("Destination index cannot be negative");
            }
            if (dstIndex + encodedSize > dst.length) {
                throw new ArrayIndexOutOfBoundsException("Buffer overflow");
            }

            // Simulate encoding: write header (8 bytes)
            Arrays.fill(dst, dstIndex, dstIndex + 8, (byte) 0xFF);
            int offset = dstIndex + 8;

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
@file:Suppress("ktlint:standard:filename")

package okhttp3.internal

import okio.ArrayIndexOutOfBoundsException
import okio.Buffer
import okio.BufferedSink
import okio.BufferedSource
import okio.ByteString.Companion.decodeHex
import okio.Closeable
import okio.FileNotFoundException
import okio.FileSystem

        void testReadBytesWireFormatInsufficientBuffer() {
            // Given
            byte[] buffer = new byte[1]; // Too small

            // When & Then
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> response.readBytesWireFormat(buffer, 0));
        }

        @Test
        @DisplayName("Should handle negative structure size as unsigned")

      assertEquals(2 * i, Strings.repeat(input, i).length());
    }

    assertThrows(IllegalArgumentException.class, () -> Strings.repeat("x", -1));
    assertThrows(
        ArrayIndexOutOfBoundsException.class, () -> Strings.repeat("12345678", (1 << 30) + 3));
  }

  @SuppressWarnings({
    "InlineMeInliner", // test of method that doesn't just delegate
    "nullness", // test of a bogus call
  })

      assertEquals(2 * i, Strings.repeat(input, i).length());
    }

    assertThrows(IllegalArgumentException.class, () -> Strings.repeat("x", -1));
    assertThrows(
        ArrayIndexOutOfBoundsException.class, () -> Strings.repeat("12345678", (1 << 30) + 3));
  }

  @SuppressWarnings({
    "InlineMeInliner", // test of method that doesn't just delegate
    "nullness", // test of a bogus call
  })

    int len = string.length();
    long longSize = (long) len * (long) count;
    int size = (int) longSize;
    if (size != longSize) {
      throw new ArrayIndexOutOfBoundsException("Required array size too large: " + longSize);
    }

    char[] array = new char[size];
    string.getChars(0, len, array, 0);
    int n;
    for (n = len; n < size - n; n <<= 1) {

            // Challenge bytes would be at 24-31 but we're truncated

            // When & Then
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> new Type2Message(truncatedMessage));
        }

        @Test
        @DisplayName("parse should handle truncated message missing target info")

        // make sure we don't exceed input's allocated size/length
        if (offset < 0 || len < 0 || (long) offset + len > input.length) {
            throw new ArrayIndexOutOfBoundsException();
        }

        // compute number of bytes still unhashed; ie. present in buffer
        int bufferNdx = (int) (count % BLOCK_LENGTH);
        count += len; // update number of bytes

        Smb2TreeConnectRequest req = new Smb2TreeConnectRequest(mockConfig, longPath);
        byte[] smallBuffer = new byte[20]; // Too small for header + path

        // When & Then
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            req.encode(smallBuffer, 0);
        });
    }

    @Test
    @DisplayName("Should correctly inherit from ServerMessageBlock2Request")
    void testInheritance() {