// When & Then - the implementation throws ArrayIndexOutOfBoundsException when buffer bounds are exceeded
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                Strings.findUNITermination(bufferWithoutTermination, 0, bufferWithoutTermination.length);
            }, "Should throw ArrayIndexOutOfBoundsException when termination not found within bounds");
        }

        @Test

    void testReadDataWireFormatWithIOException() throws Exception {
        // Create an invalid security descriptor buffer that will cause ArrayIndexOutOfBoundsException
        byte[] buffer = new byte[4];

        // Set error code to 0
        setErrorCode(response, 0);

        // ArrayIndexOutOfBoundsException is thrown when buffer is too small

        void testReadDataWireFormatEmptyBuffer() {
            byte[] buffer = new byte[0];

            // Empty buffer causes ArrayIndexOutOfBoundsException when trying to read
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                response.readDataWireFormat(buffer, 0, 0);
            });
        }

        @Test

        infoField.setAccessible(true);
        infoField.set(msrpcShareGetInfo, info502);

        // This should throw an ArrayIndexOutOfBoundsException when trying to read beyond array
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            msrpcShareGetInfo.getSecurity();
        });
    }

    @Test
    void testGetSecurityWithWrongInfoType() throws Exception {

        buffer.putShort(0, (short) 1);
        buffer.putShort(2, (short) 1);
        buffer.putInt(4, data.length + 1); // Invalid offset
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> NtlmMessage.readSecurityBuffer(data, 0),
                "Should throw ArrayIndexOutOfBoundsException for invalid offset.");
    }

    @Test

 * 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

        byte[] dst = new byte[10]; // Too small for the full parameters

        // Should throw ArrayIndexOutOfBoundsException
        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            netServerEnum2.writeParametersWireFormat(dst, 0);
        });
    }

    @Test
    @DisplayName("Test writeParametersWireFormat with large buffer succeeds")
    void testWriteParametersWireFormatLargeBuffer() {

            FileFsSizeInformation info = new FileFsSizeInformation();
            byte[] buffer = new byte[10]; // Too small

            // Should throw ArrayIndexOutOfBoundsException for insufficient buffer
            assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
                info.decode(buffer, 0, buffer.length);
            });
        }

        @ParameterizedTest

        // Create buffer smaller than required size
        byte[] smallBuffer = new byte[request.size() - 1];

        assertThrows(ArrayIndexOutOfBoundsException.class, () -> {
            request.encode(smallBuffer, 0);
        });
    }

    @Test
    @DisplayName("Test encode with offset exceeding buffer throws exception")

            byte[] data = new byte[100];
            request.setData(data, 200, 50); // Offset beyond array

            byte[] buffer = new byte[256];

            assertThrows(ArrayIndexOutOfBoundsException.class, () -> request.writeBytesWireFormat(buffer, 0));
        }

        @Test
        @DisplayName("Should handle negative offset")
        void testNegativeOffset() {