PACDecodingException exception = assertThrows(PACDecodingException.class, () -> new PacCredentialType(veryLargeData));
        assertEquals("Invalid PAC credential type", exception.getMessage());
    }

    /**
     * Tests the isCredentialTypeCorrect method with a valid byte array.
     *
     * @throws PACDecodingException if the PAC decoding fails.
     */
    @Test

        }
    }

    public void test_invalidTransliteratorId() {
        try {
            new ICUNormalizer("Invalid-Transliterator-ID-12345");
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException e) {
            assertTrue(e.getMessage().contains("Invalid transliterator ID"));
        }
    }

func ARM64RegisterShift(reg, op, count int16) (int64, error) {
	// the base register of shift operations must be general register.
	if reg > arm64.REG_R31 || reg < arm64.REG_R0 {
		return 0, errors.New("invalid register for shift operation")
	}
	return int64(reg&31)<<16 | int64(op)<<22 | int64(uint16(count)), nil
}

// ARM64RegisterArrangement constructs an ARM64 vector register arrangement.

@app.get("/items/{item_id}", response_model=Item)
async def read_main(item_id: str, x_token: Annotated[str, Header()]):
    if x_token != fake_secret_token:
        raise HTTPException(status_code=400, detail="Invalid X-Token header")
    if item_id not in fake_db:
        raise HTTPException(status_code=404, detail="Item not found")
    return fake_db[item_id]


@app.post("/items/", response_model=Item)

		"bytes=0-+3",
		"bytes=+3-+5",
		"bytes=10-11,12-10", // Unsupported by S3/MinIO (valid in RFC)
	}
	for i, urs := range unparsableRangeSpecs {
		rs, err := parseRequestRangeSpec(urs)
		if err == nil {
			t.Errorf("Case %d: Did not get an expected error - got %v", i, rs)
		}
		if isErrInvalidRange(err) {
			t.Errorf("Case %d: Got invalid range error instead of a parse error", i)
		}
		if rs != nil {

    }

    /**
     * Gets the pattern for matching invalid URLs.
     *
     * @return the invalid URL pattern
     */
    public Pattern getInvalidUrlPattern() {
        return invalidUrlPattern;
    }

    /**
     * Sets the pattern for matching invalid URLs.
     *
     * @param invalidUrlPattern the invalid URL pattern to set
     */

        assertTrue(true);
    }

    @Test
    @DisplayName("Should handle invalid protocol ID length")
    void testInvalidProtocolIdLength() {
        // Protocol ID is a constant in transform header, not settable
        // Testing invalid protocol ID during decode instead
        byte[] invalidBuffer = new byte[52];
        // Write invalid protocol ID
        invalidBuffer[0] = 0x00;
        invalidBuffer[1] = 0x00;

        if (event.getMetadata().getFile() != null) {
            metadata = event.getMetadata().getFile();
        } else {
            metadata = event.getMetadata();
        }

        String errorType = " is invalid";
        if (exception instanceof FileNotFoundException) {
            errorType = " is inaccessible";
        }

        String msg = "";
        if (exception != null) {

- Partial extraction (continues on failure)
- Invalid archive handling
- Empty archive handling
- Mixed valid/invalid entries

**Covered Extractors**:
- ZipExtractor
- TarExtractor

**Test Count**: 12 tests

**Key Scenarios**:
- ✅ Descriptive error messages for invalid archives
- ✅ Continues processing when some entries fail
- ✅ Handles empty archives gracefully
- ✅ Mixed valid/invalid entries processed correctly

	type testCase struct {
		reader      io.Reader
		expectedErr error
	}
	tests := []testCase{
		// Test - 1 valid buffer with CRLF.
		{bytes.NewReader([]byte("\r\n")), nil},
		// Test - 2 invalid buffer with no CRLF.
		{bytes.NewReader([]byte("he")), errMalformedEncoding},
		// Test - 3 invalid buffer with more characters.
		{bytes.NewReader([]byte("he\r\n")), errMalformedEncoding},
		// Test - 4 smaller buffer than expected.