"application/vnd.hydrostatix.sof-data",
				"application/vnd.hzn-3d-crossword",
				"application/vnd.ibm.afplinedata",
				"application/vnd.ibm.electronic-media",
				"application/vnd.ibm.minipay",
				"application/vnd.ibm.modcap",
				"application/vnd.ibm.rights-management",
				"application/vnd.ibm.secure-container",
				"application/vnd.iccprofile",
				"application/vnd.igloader",

import java.io.BufferedOutputStream
import java.io.File
import java.io.FileOutputStream
import java.util.jar.JarFile
import java.util.jar.JarOutputStream


@CacheableTransform
abstract class Minify : TransformAction<Minify.Parameters> {

    interface Parameters : TransformParameters {
        @get:Input
        var keepClassesByCoordinates: Map<String, Set<String>>
    }

    @get:PathSensitive(PathSensitivity.NAME_ONLY)

 * limitations under the License.
 */
import gradlebuild.basics.classanalysis.Attributes.artifactType
import gradlebuild.basics.classanalysis.Attributes.minified
import gradlebuild.basics.transforms.Minify
import org.gradle.api.internal.attributes.AttributesFactory
import org.gradle.internal.component.external.model.DefaultModuleComponentSelector
import org.gradle.kotlin.dsl.support.serviceOf

/**

        // Any PACDecodingException is acceptable for this test
        assertNotNull(e.getMessage());
    }

    @Test
    void testInvalidVersion() throws IOException {
        // Create minimal PAC structure with wrong version
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        writeLittleEndianInt(baos, 0); // buffer count = 0
        writeLittleEndianInt(baos, 99); // invalid version

import org.junit.jupiter.params.ParameterizedTest;
import org.junit.jupiter.params.provider.ValueSource;

import jcifs.pac.PACDecodingException;

class KerberosApRequestTest {

    // Helper: build a minimal, valid-looking ASN.1 AP-REQ sequence with tags 0/1/2
    private ASN1Sequence buildMinimalApReqSeq(byte apOptions) {
        ASN1EncodableVector v = new ASN1EncodableVector();
        // pvno [0] INTEGER 5

    <glob pattern="*.x3d"/>
  </mime-type>
  <mime-type type="application/vnd.ibm.afplinedata"/>
  <mime-type type="application/vnd.ibm.electronic-media"/>
  <mime-type type="application/vnd.ibm.minipay">
    <glob pattern="*.mpy"/>
  </mime-type>
  <mime-type type="application/vnd.ibm.modcap">
    <glob pattern="*.afp"/>
    <glob pattern="*.listafp"/>
    <glob pattern="*.list3820"/>
  </mime-type>

        return false;
      }
    }
    return true;
  }

  /** Returns {@code true} if this range set contains no ranges. */
  boolean isEmpty();

  /**
   * Returns the minimal range which {@linkplain Range#encloses(Range) encloses} all ranges in this
   * range set.
   *
   * @throws NoSuchElementException if this range set is {@linkplain #isEmpty() empty}
   */
  Range<C> span();

        testBuffer[5] = 0x00; // Access mask byte 1
        testBuffer[6] = 0x12; // Access mask byte 2
        testBuffer[7] = 0x00; // Access mask byte 3

        // Add minimal SID data (S-1-1-0 - Everyone)
        testBuffer[8] = 0x01; // Revision
        testBuffer[9] = 0x01; // Sub-authority count
        testBuffer[10] = 0x00; // Identifier authority
        testBuffer[11] = 0x00;

class MessageOutput(BaseModel):
    body: str = ""
    events: list[MessageEvent] = []


class Message(BaseModel):
    input: str
    output: MessageOutput


app = FastAPI(title="Minimal FastAPI App", version="1.0.0")


@app.post("/messages", response_model=Message)
async def create_message(input_message: str) -> Message:
    return Message(
        input=input_message,

            // If no exception is thrown, result should be empty or minimal
            assertNotNull("Result should not be null", result);
            assertNotNull("Content should not be null", result.getContent());
            // Empty or minimal content is acceptable for invalid archives
        } catch (final ExtractException e) {