when(sitemapsHelper.parse(any(InputStream.class))).thenThrow(new RuntimeException("Parse error"));

        // Execute and verify RuntimeException is thrown
        try {
            processor.process(responseData);
            fail("Should throw RuntimeException");
        } catch (RuntimeException e) {
            // Expected exception
            assertEquals("Parse error", e.getMessage());
        }
    }

 */
package org.codelibs.core.xml;

import static org.codelibs.core.misc.AssertionUtil.assertArgumentNotNull;

import javax.xml.XMLConstants;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.codelibs.core.exception.ParserConfigurationRuntimeException;
import org.codelibs.core.exception.SAXRuntimeException;
import org.xml.sax.SAXException;

        if (logger.isDebugEnabled()) {
            logger.debug("Parse: {} : {}", url, params);
        }
        try {
            return AuthenticationResponseParser.parse(new URI(url), params);
        } catch (final Exception e) {
            throw new SsoLoginException("Failed to parse an authentication response.", e);
        }
    }

    /**
     * Validates the nonce in the authentication result.

        _ * property.signature >> "$name-signature"
        _ * javadocConverter.parse(property, !null) >> ({[parse("<para>${args.comment ?: 'comment'}</para>")]} as DocComment)
        return property
    }

    def propertyDoc(Map<String, ?> args = [:], String name) {
        return new PropertyDoc(classMetaData(), property(name, null), [parse("<para>$name comment</para>")], args.additionalValues ?: [])
    }

     * @return The deserialized metadata, never {@code null}.
     * @throws IOException If the metadata could not be deserialized.
     * @throws MetadataParseException If the input format could not be parsed.
     */
    Metadata read(File input, Map<String, ?> options) throws IOException, MetadataParseException;

    /**

     * @return The deserialized settings, never {@code null}.
     * @throws IOException If the settings could not be deserialized.
     * @throws SettingsParseException If the input format could not be parsed.
     */
    Settings read(File input, Map<String, ?> options) throws IOException, SettingsParseException;

    /**

     * @return The deserialized toolchains, never {@code null}.
     * @throws IOException If the toolchains could not be deserialized.
     * @throws ToolchainsParseException If the input format could not be parsed.
     */
    PersistedToolchains read(File input, Map<String, ?> options) throws IOException, ToolchainsParseException;

    /**

	}

	t.Run("default", func(t *testing.T) {
		db, _ := gorm.Open(postgres.Open(postgresDSN), &gorm.Config{})
		user, err := schema.Parse(&LongString{}, &sync.Map{}, db.Config.NamingStrategy)
		if err != nil {
			t.Fatalf("failed to parse user unique, got error %v", err)
		}

		constraints := user.ParseUniqueConstraints()
		if len(constraints) != 1 {

        // Mock the parse method to return two different objects based on input
        // Must use matchers for all arguments when using any matcher
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(1), eq(new byte[] { 0x01 }), any(Map.class)))
                .thenReturn(Collections.singletonList(mockAuthData1));
        mockedStaticAuthData.when(() -> KerberosAuthData.parse(eq(2), eq(new byte[] { 0x02 }), any(Map.class)))

        // GIVEN an unknown auth type
        int unknownAuthType = -1;
        byte[] emptyToken = new byte[0];

        // WHEN parsing the auth data
        List<KerberosAuthData> result = KerberosAuthData.parse(unknownAuthType, emptyToken, mockKeys);

        // THEN the result should be an empty list
        assertNotNull(result, "The result should not be null.");