* under the License.
 */
package org.apache.maven.api.services.xml;

import org.apache.maven.api.annotations.Experimental;
import org.apache.maven.api.services.MavenException;

/**
 * An exception thrown while writing an XML file.
 *
 * @since 4.0.0
 */
@Experimental
public class XmlWriterException extends MavenException {

    private final Location location;

    /**

 */
package org.codelibs.core.exception;

import static org.codelibs.core.collection.ArrayUtil.asArray;

/**
 * Exception thrown when an argument is null.
 *
 * Intended to be used instead of throwing {@link NullPointerException}.
 *
 * @author wyukawa
 */
public class NullArgumentException extends ClIllegalArgumentException {

    /**
     *
     */

        "8.0.0" | "8.0.1"
        "1.2.3" | "1.2.4"
    }

    def "invalid version format is rejected"() {
        when:
        ReleasedVersionsHelperKt.bumpPatchVersion(version)

        then:
        thrown(IllegalArgumentException)

        where:
        version << ["9.4", "9", "9.4.0.1", "not.a.version", "9.4.0-SNAPSHOT"]
    }

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.fess.exception;

/**
 * An exception thrown when an LDAP operation fails.
 */
public class LdapOperationException extends FessSystemException {

    private static final long serialVersionUID = 1L;

    /**

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

/**
 * Exception thrown when toolchain factory operations fail.
 *
 * <p>This exception wraps errors that occur during toolchain creation or initialization.</p>
 */
public class ToolchainFactoryException extends MavenException {

/**
 * Runtime exception wrapper for ServletException.
 *
 * This exception is used to wrap checked ServletExceptions and convert them
 * into unchecked RuntimeExceptions, allowing them to be thrown from methods
 * that don't declare ServletException in their throws clause.
 */
public class ServletRuntimeException extends RuntimeException {

    /** Serial version UID for serialization compatibility. */

    } catch (AssertionError | UnsupportedOperationException expected) {
      // UnsupportedOperationException is what we see on Android.
      return;
    }
    fail("Should have thrown");
  }

  @AndroidIncompatible // TODO(cpovirk): java.lang.IllegalAccessError: superclass not accessible
  public void testSuccessfulForwarding() {
    ForwardingObjectTester.testForwardingObject(ForwardToDelegate.class);

   *         <li>If the next character was not a low surrogate value, then {@link
   *             IllegalArgumentException} is thrown.
   *       </ol>
   *   <li>If the first character was a low surrogate value, {@link IllegalArgumentException} is
   *       thrown.
   * </ol>
   *
   * @param seq the sequence of characters from which to decode the code point

    val thread =
      object : Thread() {
        override fun run(): Unit = throw RuntimeException("boom!")
      }
    thread.start()
    thread.join()

    assertFailsWith<AssertionError> {
      testRule.afterEach(extensionContext)
    }.also { expected ->
      assertThat(expected).hasMessage("uncaught exception thrown during test")
      assertThat(expected.cause!!).hasMessage("boom!")
    }
  }

 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.api.services;

/**
 * Exceptions thrown by the {@link SuperPomProvider} service.
 *
 * @since 4.0.0
 */
public class SuperPomProviderException extends MavenException {

    public SuperPomProviderException() {
        super();
    }