// ***************************************************************************************************************************
// * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements.  See the NOTICE file *
// * distributed with this work for additional information regarding copyright ownership.  The ASF licenses this file        *
// * to you under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance            *
// * with the License.  You may obtain a copy of the License at                                                              *
// *                                                                                                                         *
// *  http://www.apache.org/licenses/LICENSE-2.0                                                                             *
// *                                                                                                                         *
// * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an  *
// * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the License for the        *
// * specific language governing permissions and limitations under the License.                                              *
// ***************************************************************************************************************************
package org.apache.juneau.rest;

import static org.apache.juneau.rest.testutils.TestUtils.*;

import static org.junit.Assert.*;
import static org.junit.runners.MethodSorters.*;

import java.util.*;

import org.apache.juneau.dto.swagger.*;
import org.apache.juneau.rest.annotation.*;
import org.apache.juneau.rest.client2.*;
import org.apache.juneau.rest.helper.*;
import org.apache.juneau.rest.mock2.*;
import org.apache.juneau.http.exception.*;
import org.apache.juneau.json.*;
import org.apache.juneau.parser.*;
import org.junit.*;

@FixMethodOrder(NAME_ASCENDING)
public class RestMethod_Throws_Test {
	//-----------------------------------------------------------------------------------------------------------------
	// Basic sanity tests
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class A {
		@RestMethod public void badRequest() { throw new BadRequest(); }
		@RestMethod public void conflict() { throw new Conflict(); }
		@RestMethod public void expectationFailed() { throw new ExpectationFailed(); }
		@RestMethod public void failedDependency() { throw new FailedDependency(); }
		@RestMethod public void forbidden() { throw new Forbidden(); }
		@RestMethod public void gone() { throw new Gone(); }
		@RestMethod public void httpVersionNotSupported() { throw new HttpVersionNotSupported(); }
		@RestMethod public void insufficientStorage() { throw new InsufficientStorage(); }
		@RestMethod public void internalServerError() { throw new InternalServerError(); }
		@RestMethod public void lengthRequired() { throw new LengthRequired(); }
		@RestMethod public void locked() { throw new Locked(); }
		@RestMethod public void loopDetected() { throw new LoopDetected(); }
		@RestMethod public void methodNotAllowed() { throw new MethodNotAllowed(); }
		@RestMethod public void misdirectedRequest() { throw new MisdirectedRequest(); }
		@RestMethod public void networkAuthenticationRequired() { throw new NetworkAuthenticationRequired(); }
		@RestMethod public void notAcceptable() { throw new NotAcceptable(); }
		@RestMethod public void notExtended() { throw new NotExtended(); }
		@RestMethod public void notFound() { throw new NotFound(); }
		@RestMethod public void notImplemented() { throw new NotImplemented(); }
		@RestMethod public void payloadTooLarge() { throw new PayloadTooLarge(); }
		@RestMethod public void preconditionFailed() { throw new PreconditionFailed(); }
		@RestMethod public void preconditionRequired() { throw new PreconditionRequired(); }
		@RestMethod public void rangeNotSatisfiable() { throw new RangeNotSatisfiable(); }
		@RestMethod public void requestHeaderFieldsTooLarge() { throw new RequestHeaderFieldsTooLarge(); }
		@RestMethod public void serviceUnavailable() { throw new ServiceUnavailable(); }
		@RestMethod public void tooManyRequests() { throw new TooManyRequests(); }
		@RestMethod public void unauthorized() { throw new Unauthorized(); }
		@RestMethod public void unavailableForLegalReasons() { throw new UnavailableForLegalReasons(); }
		@RestMethod public void unprocessableEntity() { throw new UnprocessableEntity(); }
		@RestMethod public void unsupportedMediaType() { throw new UnsupportedMediaType(); }
		@RestMethod public void upgradeRequired() { throw new UpgradeRequired(); }
		@RestMethod public void uriTooLong() { throw new UriTooLong(); }
		@RestMethod public void variantAlsoNegotiates() { throw new VariantAlsoNegotiates(); }
	}

	@Test
	public void a01_noArgs() throws Exception {
		RestClient a = MockRestClient.buildLax(A.class);
		a.get("/badRequest")
			.run()
			.assertCode().is(400)
			.assertBody().is("Bad Request");
		a.get("/conflict")
			.run()
			.assertCode().is(409)
			.assertBody().is("Conflict");
		a.get("/expectationFailed")
			.run()
			.assertCode().is(417)
			.assertBody().is("Expectation Failed");
		a.get("/failedDependency")
			.run()
			.assertCode().is(424)
			.assertBody().is("Failed Dependency");
		a.get("/forbidden")
			.run()
			.assertCode().is(403)
			.assertBody().is("Forbidden");
		a.get("/gone")
			.run()
			.assertCode().is(410)
			.assertBody().is("Gone");
		a.get("/httpVersionNotSupported")
			.run()
			.assertCode().is(505)
			.assertBody().is("HTTP Version Not Supported");
		a.get("/insufficientStorage")
			.run()
			.assertCode().is(507)
			.assertBody().is("Insufficient Storage");
		a.get("/internalServerError")
			.run()
			.assertCode().is(500)
			.assertBody().is("Internal Server Error");
		a.get("/lengthRequired")
			.run()
			.assertCode().is(411)
			.assertBody().is("Length Required");
		a.get("/locked")
			.run()
			.assertCode().is(423)
			.assertBody().is("Locked");
		a.get("/loopDetected")
			.run()
			.assertCode().is(508)
			.assertBody().is("Loop Detected");
		a.get("/methodNotAllowed")
			.run()
			.assertCode().is(405)
			.assertBody().is("Method Not Allowed");
		a.get("/misdirectedRequest")
			.run()
			.assertCode().is(421)
			.assertBody().is("Misdirected Request");
		a.get("/networkAuthenticationRequired")
			.run()
			.assertCode().is(511)
			.assertBody().is("Network Authentication Required");
		a.get("/notAcceptable")
			.run()
			.assertCode().is(406)
			.assertBody().is("Not Acceptable");
		a.get("/notExtended")
			.run()
			.assertCode().is(510)
			.assertBody().is("Not Extended");
		a.get("/notFound")
			.run()
			.assertCode().is(404)
			.assertBody().is("Not Found");
		a.get("/notImplemented")
			.run()
			.assertCode().is(501)
			.assertBody().is("Not Implemented");
		a.get("/payloadTooLarge")
			.run()
			.assertCode().is(413)
			.assertBody().is("Payload Too Large");
		a.get("/preconditionFailed")
			.run()
			.assertCode().is(412)
			.assertBody().is("Precondition Failed");
		a.get("/preconditionRequired")
			.run()
			.assertCode().is(428)
			.assertBody().is("Precondition Required");
		a.get("/rangeNotSatisfiable")
			.run()
			.assertCode().is(416)
			.assertBody().is("Range Not Satisfiable");
		a.get("/requestHeaderFieldsTooLarge")
			.run()
			.assertCode().is(431)
			.assertBody().is("Request Header Fields Too Large");
		a.get("/serviceUnavailable")
			.run()
			.assertCode().is(503)
			.assertBody().is("Service Unavailable");
		a.get("/tooManyRequests")
			.run()
			.assertCode().is(429)
			.assertBody().is("Too Many Requests");
		a.get("/unauthorized")
			.run()
			.assertCode().is(401)
			.assertBody().is("Unauthorized");
		a.get("/unavailableForLegalReasons")
			.run()
			.assertCode().is(451)
			.assertBody().is("Unavailable For Legal Reasons");
		a.get("/unprocessableEntity")
			.run()
			.assertCode().is(422)
			.assertBody().is("Unprocessable Entity");
		a.get("/unsupportedMediaType")
			.run()
			.assertCode().is(415)
			.assertBody().is("Unsupported Media Type");
		a.get("/upgradeRequired")
			.run()
			.assertCode().is(426)
			.assertBody().is("Upgrade Required");
		a.get("/uriTooLong")
			.run()
			.assertCode().is(414)
			.assertBody().is("URI Too Long");
		a.get("/variantAlsoNegotiates")
			.run()
			.assertCode().is(506)
			.assertBody().is("Variant Also Negotiates");
	}

	//-----------------------------------------------------------------------------------------------------------------
	// User-specified message
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class B {
		@RestMethod public void badRequest() { throw new BadRequest("foo {0}", "bar"); }
		@RestMethod public void conflict() { throw new Conflict("foo {0}", "bar"); }
		@RestMethod public void expectationFailed() { throw new ExpectationFailed("foo {0}", "bar"); }
		@RestMethod public void failedDependency() { throw new FailedDependency("foo {0}", "bar"); }
		@RestMethod public void forbidden() { throw new Forbidden("foo {0}", "bar"); }
		@RestMethod public void gone() { throw new Gone("foo {0}", "bar"); }
		@RestMethod public void httpVersionNotSupported() { throw new HttpVersionNotSupported("foo {0}", "bar"); }
		@RestMethod public void insufficientStorage() { throw new InsufficientStorage("foo {0}", "bar"); }
		@RestMethod public void internalServerError() { throw new InternalServerError("foo {0}", "bar"); }
		@RestMethod public void lengthRequired() { throw new LengthRequired("foo {0}", "bar"); }
		@RestMethod public void locked() { throw new Locked("foo {0}", "bar"); }
		@RestMethod public void loopDetected() { throw new LoopDetected("foo {0}", "bar"); }
		@RestMethod public void methodNotAllowed() { throw new MethodNotAllowed("foo {0}", "bar"); }
		@RestMethod public void misdirectedRequest() { throw new MisdirectedRequest("foo {0}", "bar"); }
		@RestMethod public void networkAuthenticationRequired() { throw new NetworkAuthenticationRequired("foo {0}", "bar"); }
		@RestMethod public void notAcceptable() { throw new NotAcceptable("foo {0}", "bar"); }
		@RestMethod public void notExtended() { throw new NotExtended("foo {0}", "bar"); }
		@RestMethod public void notFound() { throw new NotFound("foo {0}", "bar"); }
		@RestMethod public void notImplemented() { throw new NotImplemented("foo {0}", "bar"); }
		@RestMethod public void payloadTooLarge() { throw new PayloadTooLarge("foo {0}", "bar"); }
		@RestMethod public void preconditionFailed() { throw new PreconditionFailed("foo {0}", "bar"); }
		@RestMethod public void preconditionRequired() { throw new PreconditionRequired("foo {0}", "bar"); }
		@RestMethod public void rangeNotSatisfiable() { throw new RangeNotSatisfiable("foo {0}", "bar"); }
		@RestMethod public void requestHeaderFieldsTooLarge() { throw new RequestHeaderFieldsTooLarge("foo {0}", "bar"); }
		@RestMethod public void serviceUnavailable() { throw new ServiceUnavailable("foo {0}", "bar"); }
		@RestMethod public void tooManyRequests() { throw new TooManyRequests("foo {0}", "bar"); }
		@RestMethod public void unauthorized() { throw new Unauthorized("foo {0}", "bar"); }
		@RestMethod public void unavailableForLegalReasons() { throw new UnavailableForLegalReasons("foo {0}", "bar"); }
		@RestMethod public void unprocessableEntity() { throw new UnprocessableEntity("foo {0}", "bar"); }
		@RestMethod public void unsupportedMediaType() { throw new UnsupportedMediaType("foo {0}", "bar"); }
		@RestMethod public void upgradeRequired() { throw new UpgradeRequired("foo {0}", "bar"); }
		@RestMethod public void uriTooLong() { throw new UriTooLong("foo {0}", "bar"); }
		@RestMethod public void variantAlsoNegotiates() { throw new VariantAlsoNegotiates("foo {0}", "bar"); }
	}


	@Test
	public void b01_userSpecifiedMessage() throws Exception {
		RestClient b = MockRestClient.buildLax(B.class);
		b.get("/badRequest")
			.run()
			.assertCode().is(400)
			.assertBody().is("foo bar");
		b.get("/conflict")
			.run()
			.assertCode().is(409)
			.assertBody().is("foo bar");
		b.get("/expectationFailed")
			.run()
			.assertCode().is(417)
			.assertBody().is("foo bar");
		b.get("/failedDependency")
			.run()
			.assertCode().is(424)
			.assertBody().is("foo bar");
		b.get("/forbidden")
			.run()
			.assertCode().is(403)
			.assertBody().is("foo bar");
		b.get("/gone")
			.run()
			.assertCode().is(410)
			.assertBody().is("foo bar");
		b.get("/httpVersionNotSupported")
			.run()
			.assertCode().is(505)
			.assertBody().is("foo bar");
		b.get("/insufficientStorage")
			.run()
			.assertCode().is(507)
			.assertBody().is("foo bar");
		b.get("/internalServerError")
			.run()
			.assertCode().is(500)
			.assertBody().is("foo bar");
		b.get("/lengthRequired")
			.run()
			.assertCode().is(411)
			.assertBody().is("foo bar");
		b.get("/locked")
			.run()
			.assertCode().is(423)
			.assertBody().is("foo bar");
		b.get("/loopDetected")
			.run()
			.assertCode().is(508)
			.assertBody().is("foo bar");
		b.get("/methodNotAllowed")
			.run()
			.assertCode().is(405)
			.assertBody().is("foo bar");
		b.get("/misdirectedRequest")
			.run()
			.assertCode().is(421)
			.assertBody().is("foo bar");
		b.get("/networkAuthenticationRequired")
			.run()
			.assertCode().is(511)
			.assertBody().is("foo bar");
		b.get("/notAcceptable")
			.run()
			.assertCode().is(406)
			.assertBody().is("foo bar");
		b.get("/notExtended")
			.run()
			.assertCode().is(510)
			.assertBody().is("foo bar");
		b.get("/notFound")
			.run()
			.assertCode().is(404)
			.assertBody().is("foo bar");
		b.get("/notImplemented")
			.run()
			.assertCode().is(501)
			.assertBody().is("foo bar");
		b.get("/payloadTooLarge")
			.run()
			.assertCode().is(413)
			.assertBody().is("foo bar");
		b.get("/preconditionFailed")
			.run()
			.assertCode().is(412)
			.assertBody().is("foo bar");
		b.get("/preconditionRequired")
			.run()
			.assertCode().is(428)
			.assertBody().is("foo bar");
		b.get("/rangeNotSatisfiable")
			.run()
			.assertCode().is(416)
			.assertBody().is("foo bar");
		b.get("/requestHeaderFieldsTooLarge")
			.run()
			.assertCode().is(431)
			.assertBody().is("foo bar");
		b.get("/serviceUnavailable")
			.run()
			.assertCode().is(503)
			.assertBody().is("foo bar");
		b.get("/tooManyRequests")
			.run()
			.assertCode().is(429)
			.assertBody().is("foo bar");
		b.get("/unauthorized")
			.run()
			.assertCode().is(401)
			.assertBody().is("foo bar");
		b.get("/unavailableForLegalReasons")
			.run()
			.assertCode().is(451)
			.assertBody().is("foo bar");
		b.get("/unprocessableEntity")
			.run()
			.assertCode().is(422)
			.assertBody().is("foo bar");
		b.get("/unsupportedMediaType")
			.run()
			.assertCode().is(415)
			.assertBody().is("foo bar");
		b.get("/upgradeRequired")
			.run()
			.assertCode().is(426)
			.assertBody().is("foo bar");
		b.get("/uriTooLong")
			.run()
			.assertCode().is(414)
			.assertBody().is("foo bar");
		b.get("/variantAlsoNegotiates")
			.run()
			.assertCode().is(506)
			.assertBody().is("foo bar");
	}

	//-----------------------------------------------------------------------------------------------------------------
	// Throwable
	//-----------------------------------------------------------------------------------------------------------------

	static final Throwable t = new Throwable("foo");

	@Rest
	public static class C {
		@RestMethod public void badRequest() { throw new BadRequest(t); }
		@RestMethod public void conflict() { throw new Conflict(t); }
		@RestMethod public void expectationFailed() { throw new ExpectationFailed(t); }
		@RestMethod public void failedDependency() { throw new FailedDependency(t); }
		@RestMethod public void forbidden() { throw new Forbidden(t); }
		@RestMethod public void gone() { throw new Gone(t); }
		@RestMethod public void httpVersionNotSupported() { throw new HttpVersionNotSupported(t); }
		@RestMethod public void insufficientStorage() { throw new InsufficientStorage(t); }
		@RestMethod public void internalServerError() { throw new InternalServerError(t); }
		@RestMethod public void lengthRequired() { throw new LengthRequired(t); }
		@RestMethod public void locked() { throw new Locked(t); }
		@RestMethod public void loopDetected() { throw new LoopDetected(t); }
		@RestMethod public void methodNotAllowed() { throw new MethodNotAllowed(t); }
		@RestMethod public void misdirectedRequest() { throw new MisdirectedRequest(t); }
		@RestMethod public void networkAuthenticationRequired() { throw new NetworkAuthenticationRequired(t); }
		@RestMethod public void notAcceptable() { throw new NotAcceptable(t); }
		@RestMethod public void notExtended() { throw new NotExtended(t); }
		@RestMethod public void notFound() { throw new NotFound(t); }
		@RestMethod public void notImplemented() { throw new NotImplemented(t); }
		@RestMethod public void payloadTooLarge() { throw new PayloadTooLarge(t); }
		@RestMethod public void preconditionFailed() { throw new PreconditionFailed(t); }
		@RestMethod public void preconditionRequired() { throw new PreconditionRequired(t); }
		@RestMethod public void rangeNotSatisfiable() { throw new RangeNotSatisfiable(t); }
		@RestMethod public void requestHeaderFieldsTooLarge() { throw new RequestHeaderFieldsTooLarge(t); }
		@RestMethod public void serviceUnavailable() { throw new ServiceUnavailable(t); }
		@RestMethod public void tooManyRequests() { throw new TooManyRequests(t); }
		@RestMethod public void unauthorized() { throw new Unauthorized(t); }
		@RestMethod public void unavailableForLegalReasons() { throw new UnavailableForLegalReasons(t); }
		@RestMethod public void unprocessableEntity() { throw new UnprocessableEntity(t); }
		@RestMethod public void unsupportedMediaType() { throw new UnsupportedMediaType(t); }
		@RestMethod public void upgradeRequired() { throw new UpgradeRequired(t); }
		@RestMethod public void uriTooLong() { throw new UriTooLong(t); }
		@RestMethod public void variantAlsoNegotiates() { throw new VariantAlsoNegotiates(t); }
	}

	@Test
	public void c01_nestedThrowable() throws Exception {
		RestClient c = MockRestClient.buildLax(C.class);
		c.get("/badRequest")
			.run()
			.assertCode().is(400)
			.assertBody().is("foo");
		c.get("/conflict")
			.run()
			.assertCode().is(409)
			.assertBody().is("foo");
		c.get("/expectationFailed")
			.run()
			.assertCode().is(417)
			.assertBody().is("foo");
		c.get("/failedDependency")
			.run()
			.assertCode().is(424)
			.assertBody().is("foo");
		c.get("/forbidden")
			.run()
			.assertCode().is(403)
			.assertBody().is("foo");
		c.get("/gone")
			.run()
			.assertCode().is(410)
			.assertBody().is("foo");
		c.get("/httpVersionNotSupported")
			.run()
			.assertCode().is(505)
			.assertBody().is("foo");
		c.get("/insufficientStorage")
			.run()
			.assertCode().is(507)
			.assertBody().is("foo");
		c.get("/internalServerError")
			.run()
			.assertCode().is(500)
			.assertBody().is("foo");
		c.get("/lengthRequired")
			.run()
			.assertCode().is(411)
			.assertBody().is("foo");
		c.get("/locked")
			.run()
			.assertCode().is(423)
			.assertBody().is("foo");
		c.get("/loopDetected")
			.run()
			.assertCode().is(508)
			.assertBody().is("foo");
		c.get("/methodNotAllowed")
			.run()
			.assertCode().is(405)
			.assertBody().is("foo");
		c.get("/misdirectedRequest")
			.run()
			.assertCode().is(421)
			.assertBody().is("foo");
		c.get("/networkAuthenticationRequired")
			.run()
			.assertCode().is(511)
			.assertBody().is("foo");
		c.get("/notAcceptable")
			.run()
			.assertCode().is(406)
			.assertBody().is("foo");
		c.get("/notExtended")
			.run()
			.assertCode().is(510)
			.assertBody().is("foo");
		c.get("/notFound")
			.run()
			.assertCode().is(404)
			.assertBody().is("foo");
		c.get("/notImplemented")
			.run()
			.assertCode().is(501)
			.assertBody().is("foo");
		c.get("/payloadTooLarge")
			.run()
			.assertCode().is(413)
			.assertBody().is("foo");
		c.get("/preconditionFailed").
			run()
			.assertCode().is(412)
			.assertBody().is("foo");
		c.get("/preconditionRequired")
			.run()
			.assertCode().is(428)
			.assertBody().is("foo");
		c.get("/rangeNotSatisfiable")
			.run()
			.assertCode().is(416)
			.assertBody().is("foo");
		c.get("/requestHeaderFieldsTooLarge")
			.run()
			.assertCode().is(431)
			.assertBody().is("foo");
		c.get("/serviceUnavailable")
			.run()
			.assertCode().is(503)
			.assertBody().is("foo");
		c.get("/tooManyRequests")
			.run()
			.assertCode().is(429)
			.assertBody().is("foo");
		c.get("/unauthorized")
			.run()
			.assertCode().is(401)
			.assertBody().is("foo");
		c.get("/unavailableForLegalReasons")
			.run()
			.assertCode().is(451)
			.assertBody().is("foo");
		c.get("/unprocessableEntity")
			.run()
			.assertCode().is(422)
			.assertBody().is("foo");
		c.get("/unsupportedMediaType")
			.run()
			.assertCode().is(415)
			.assertBody().is("foo");
		c.get("/upgradeRequired")
			.run()
			.assertCode().is(426)
			.assertBody().is("foo");
		c.get("/uriTooLong")
			.run()
			.assertCode().is(414)
			.assertBody().is("foo");
		c.get("/variantAlsoNegotiates")
			.run()
			.assertCode().is(506)
			.assertBody().is("foo");
	}

	//-----------------------------------------------------------------------------------------------------------------
	// Throwable with message
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class D {
		@RestMethod public void badRequest() { throw new BadRequest(t, "foo {0}", "bar"); }
		@RestMethod public void conflict() { throw new Conflict(t, "foo {0}", "bar"); }
		@RestMethod public void expectationFailed() { throw new ExpectationFailed(t, "foo {0}", "bar"); }
		@RestMethod public void failedDependency() { throw new FailedDependency(t, "foo {0}", "bar"); }
		@RestMethod public void forbidden() { throw new Forbidden(t, "foo {0}", "bar"); }
		@RestMethod public void gone() { throw new Gone(t, "foo {0}", "bar"); }
		@RestMethod public void httpVersionNotSupported() { throw new HttpVersionNotSupported(t, "foo {0}", "bar"); }
		@RestMethod public void insufficientStorage() { throw new InsufficientStorage(t, "foo {0}", "bar"); }
		@RestMethod public void internalServerError() { throw new InternalServerError(t, "foo {0}", "bar"); }
		@RestMethod public void lengthRequired() { throw new LengthRequired(t, "foo {0}", "bar"); }
		@RestMethod public void locked() { throw new Locked(t, "foo {0}", "bar"); }
		@RestMethod public void loopDetected() { throw new LoopDetected(t, "foo {0}", "bar"); }
		@RestMethod public void methodNotAllowed() { throw new MethodNotAllowed(t, "foo {0}", "bar"); }
		@RestMethod public void misdirectedRequest() { throw new MisdirectedRequest(t, "foo {0}", "bar"); }
		@RestMethod public void networkAuthenticationRequired() { throw new NetworkAuthenticationRequired(t, "foo {0}", "bar"); }
		@RestMethod public void notAcceptable() { throw new NotAcceptable(t, "foo {0}", "bar"); }
		@RestMethod public void notExtended() { throw new NotExtended(t, "foo {0}", "bar"); }
		@RestMethod public void notFound() { throw new NotFound(t, "foo {0}", "bar"); }
		@RestMethod public void notImplemented() { throw new NotImplemented(t, "foo {0}", "bar"); }
		@RestMethod public void payloadTooLarge() { throw new PayloadTooLarge(t, "foo {0}", "bar"); }
		@RestMethod public void preconditionFailed() { throw new PreconditionFailed(t, "foo {0}", "bar"); }
		@RestMethod public void preconditionRequired() { throw new PreconditionRequired(t, "foo {0}", "bar"); }
		@RestMethod public void rangeNotSatisfiable() { throw new RangeNotSatisfiable(t, "foo {0}", "bar"); }
		@RestMethod public void requestHeaderFieldsTooLarge() { throw new RequestHeaderFieldsTooLarge(t, "foo {0}", "bar"); }
		@RestMethod public void serviceUnavailable() { throw new ServiceUnavailable(t, "foo {0}", "bar"); }
		@RestMethod public void tooManyRequests() { throw new TooManyRequests(t, "foo {0}", "bar"); }
		@RestMethod public void unauthorized() { throw new Unauthorized(t, "foo {0}", "bar"); }
		@RestMethod public void unavailableForLegalReasons() { throw new UnavailableForLegalReasons(t, "foo {0}", "bar"); }
		@RestMethod public void unprocessableEntity() { throw new UnprocessableEntity(t, "foo {0}", "bar"); }
		@RestMethod public void unsupportedMediaType() { throw new UnsupportedMediaType(t, "foo {0}", "bar"); }
		@RestMethod public void upgradeRequired() { throw new UpgradeRequired(t, "foo {0}", "bar"); }
		@RestMethod public void uriTooLong() { throw new UriTooLong(t, "foo {0}", "bar"); }
		@RestMethod public void variantAlsoNegotiates() { throw new VariantAlsoNegotiates(t, "foo {0}", "bar"); }
	}

	@Test
	public void d01_nestedThrowableWithMessage() throws Exception {
		RestClient d = MockRestClient.buildLax(D.class);
		d.get("/badRequest")
			.run()
			.assertCode().is(400)
			.assertBody().is("foo bar");
		d.get("/conflict")
			.run()
			.assertCode().is(409)
			.assertBody().is("foo bar");
		d.get("/expectationFailed")
			.run()
			.assertCode().is(417)
			.assertBody().is("foo bar");
		d.get("/failedDependency")
			.run()
			.assertCode().is(424)
			.assertBody().is("foo bar");
		d.get("/forbidden")
			.run()
			.assertCode().is(403)
			.assertBody().is("foo bar");
		d.get("/gone")
			.run()
			.assertCode().is(410)
			.assertBody().is("foo bar");
		d.get("/httpVersionNotSupported")
			.run()
			.assertCode().is(505)
			.assertBody().is("foo bar");
		d.get("/insufficientStorage")
			.run()
			.assertCode().is(507)
			.assertBody().is("foo bar");
		d.get("/internalServerError")
			.run()
			.assertCode().is(500)
			.assertBody().is("foo bar");
		d.get("/lengthRequired")
			.run()
			.assertCode().is(411)
			.assertBody().is("foo bar");
		d.get("/locked")
			.run()
			.assertCode().is(423)
			.assertBody().is("foo bar");
		d.get("/loopDetected")
			.run()
			.assertCode().is(508)
			.assertBody().is("foo bar");
		d.get("/methodNotAllowed")
			.run()
			.assertCode().is(405)
			.assertBody().is("foo bar");
		d.get("/misdirectedRequest")
			.run()
			.assertCode().is(421)
			.assertBody().is("foo bar");
		d.get("/networkAuthenticationRequired")
			.run()
			.assertCode().is(511)
			.assertBody().is("foo bar");
		d.get("/notAcceptable")
			.run()
			.assertCode().is(406)
			.assertBody().is("foo bar");
		d.get("/notExtended")
			.run()
			.assertCode().is(510)
			.assertBody().is("foo bar");
		d.get("/notFound")
			.run()
			.assertCode().is(404)
			.assertBody().is("foo bar");
		d.get("/notImplemented")
			.run()
			.assertCode().is(501)
			.assertBody().is("foo bar");
		d.get("/payloadTooLarge")
			.run()
			.assertCode().is(413)
			.assertBody().is("foo bar");
		d.get("/preconditionFailed")
			.run()
			.assertCode().is(412)
			.assertBody().is("foo bar");
		d.get("/preconditionRequired")
			.run()
			.assertCode().is(428)
			.assertBody().is("foo bar");
		d.get("/rangeNotSatisfiable")
			.run()
			.assertCode().is(416)
			.assertBody().is("foo bar");
		d.get("/requestHeaderFieldsTooLarge")
			.run()
			.assertCode().is(431)
			.assertBody().is("foo bar");
		d.get("/serviceUnavailable")
			.run()
			.assertCode().is(503)
			.assertBody().is("foo bar");
		d.get("/tooManyRequests")
			.run()
			.assertCode().is(429)
			.assertBody().is("foo bar");
		d.get("/unauthorized")
			.run()
			.assertCode().is(401)
			.assertBody().is("foo bar");
		d.get("/unavailableForLegalReasons")
			.run()
			.assertCode().is(451)
			.assertBody().is("foo bar");
		d.get("/unprocessableEntity")
			.run()
			.assertCode().is(422)
			.assertBody().is("foo bar");
		d.get("/unsupportedMediaType")
			.run()
			.assertCode().is(415)
			.assertBody().is("foo bar");
		d.get("/upgradeRequired")
			.run()
			.assertCode().is(426)
			.assertBody().is("foo bar");
		d.get("/uriTooLong")
			.run()
			.assertCode().is(414)
			.assertBody().is("foo bar");
		d.get("/variantAlsoNegotiates")
			.run()
			.assertCode().is(506)
			.assertBody().is("foo bar");
	}

	//-----------------------------------------------------------------------------------------------------------------
	// Should use Accept language for serialization.
	//-----------------------------------------------------------------------------------------------------------------

	@Rest(serializers=SimpleJsonSerializer.class)
	public static class E {
		@RestMethod public void badRequest() { throw new BadRequest(t, "foo {0}", "bar"); }
	}

	@Test
	public void e01_useAcceptForSerialization() throws Exception {
		RestClient e = MockRestClient.buildLax(E.class);
		e.get("/badRequest")
			.json()
			.run()
			.assertCode().is(400)
			.assertBody().is("'foo bar'");
	}

	//-----------------------------------------------------------------------------------------------------------------
	// Test Swagger
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class F {
		@RestMethod public void badRequest() throws BadRequest {}
		@RestMethod public void conflict() throws Conflict {}
		@RestMethod public void expectationFailed() throws ExpectationFailed {}
		@RestMethod public void failedDependency() throws FailedDependency {}
		@RestMethod public void forbidden() throws Forbidden {}
		@RestMethod public void gone() throws Gone {}
		@RestMethod public void httpVersionNotSupported() throws HttpVersionNotSupported {}
		@RestMethod public void insufficientStorage() throws InsufficientStorage {}
		@RestMethod public void internalServerError() throws InternalServerError {}
		@RestMethod public void lengthRequired() throws LengthRequired {}
		@RestMethod public void locked() throws Locked {}
		@RestMethod public void loopDetected() throws LoopDetected {}
		@RestMethod public void methodNotAllowed() throws MethodNotAllowed {}
		@RestMethod public void misdirectedRequest() throws MisdirectedRequest {}
		@RestMethod public void networkAuthenticationRequired() throws NetworkAuthenticationRequired {}
		@RestMethod public void notAcceptable() throws NotAcceptable {}
		@RestMethod public void notExtended() throws NotExtended {}
		@RestMethod public void notFound() throws NotFound {}
		@RestMethod public void notImplemented() throws NotImplemented {}
		@RestMethod public void payloadTooLarge() throws PayloadTooLarge {}
		@RestMethod public void preconditionFailed() throws PreconditionFailed {}
		@RestMethod public void preconditionRequired() throws PreconditionRequired {}
		@RestMethod public void rangeNotSatisfiable() throws RangeNotSatisfiable {}
		@RestMethod public void requestHeaderFieldsTooLarge() throws RequestHeaderFieldsTooLarge {}
		@RestMethod public void serviceUnavailable() throws ServiceUnavailable {}
		@RestMethod public void tooManyRequests() throws TooManyRequests {}
		@RestMethod public void unauthorized() throws Unauthorized {}
		@RestMethod public void unavailableForLegalReasons() throws UnavailableForLegalReasons {}
		@RestMethod public void unprocessableEntity() throws UnprocessableEntity {}
		@RestMethod public void unsupportedMediaType() throws UnsupportedMediaType {}
		@RestMethod public void upgradeRequired() throws UpgradeRequired {}
		@RestMethod public void uriTooLong() throws UriTooLong {}
		@RestMethod public void variantAlsoNegotiates() throws VariantAlsoNegotiates {}
	}

	@Test
	public void f01_swagger() throws Exception {
		Map<String,OperationMap> paths = getSwagger(F.class).getPaths();

		assertEquals(BadRequest.MESSAGE, paths.get("/badRequest").get("get").getResponse(BadRequest.CODE).getDescription());
		assertEquals(Conflict.MESSAGE, paths.get("/conflict").get("get").getResponse(Conflict.CODE).getDescription());
		assertEquals(ExpectationFailed.MESSAGE, paths.get("/expectationFailed").get("get").getResponse(ExpectationFailed.CODE).getDescription());
		assertEquals(FailedDependency.MESSAGE, paths.get("/failedDependency").get("get").getResponse(FailedDependency.CODE).getDescription());
		assertEquals(Forbidden.MESSAGE, paths.get("/forbidden").get("get").getResponse(Forbidden.CODE).getDescription());
		assertEquals(Gone.MESSAGE, paths.get("/gone").get("get").getResponse(Gone.CODE).getDescription());
		assertEquals(HttpVersionNotSupported.MESSAGE, paths.get("/httpVersionNotSupported").get("get").getResponse(HttpVersionNotSupported.CODE).getDescription());
		assertEquals(InsufficientStorage.MESSAGE, paths.get("/insufficientStorage").get("get").getResponse(InsufficientStorage.CODE).getDescription());
		assertEquals(InternalServerError.MESSAGE, paths.get("/internalServerError").get("get").getResponse(InternalServerError.CODE).getDescription());
		assertEquals(LengthRequired.MESSAGE, paths.get("/lengthRequired").get("get").getResponse(LengthRequired.CODE).getDescription());
		assertEquals(Locked.MESSAGE, paths.get("/locked").get("get").getResponse(Locked.CODE).getDescription());
		assertEquals(LoopDetected.MESSAGE, paths.get("/loopDetected").get("get").getResponse(LoopDetected.CODE).getDescription());
		assertEquals(MethodNotAllowed.MESSAGE, paths.get("/methodNotAllowed").get("get").getResponse(MethodNotAllowed.CODE).getDescription());
		assertEquals(MisdirectedRequest.MESSAGE, paths.get("/misdirectedRequest").get("get").getResponse(MisdirectedRequest.CODE).getDescription());
		assertEquals(NetworkAuthenticationRequired.MESSAGE, paths.get("/networkAuthenticationRequired").get("get").getResponse(NetworkAuthenticationRequired.CODE).getDescription());
		assertEquals(NotAcceptable.MESSAGE, paths.get("/notAcceptable").get("get").getResponse(NotAcceptable.CODE).getDescription());
		assertEquals(NotExtended.MESSAGE, paths.get("/notExtended").get("get").getResponse(NotExtended.CODE).getDescription());
		assertEquals(NotFound.MESSAGE, paths.get("/notFound").get("get").getResponse(NotFound.CODE).getDescription());
		assertEquals(NotImplemented.MESSAGE, paths.get("/notImplemented").get("get").getResponse(NotImplemented.CODE).getDescription());
		assertEquals(PayloadTooLarge.MESSAGE, paths.get("/payloadTooLarge").get("get").getResponse(PayloadTooLarge.CODE).getDescription());
		assertEquals(PreconditionFailed.MESSAGE, paths.get("/preconditionFailed").get("get").getResponse(PreconditionFailed.CODE).getDescription());
		assertEquals(PreconditionRequired.MESSAGE, paths.get("/preconditionRequired").get("get").getResponse(PreconditionRequired.CODE).getDescription());
		assertEquals(RangeNotSatisfiable.MESSAGE, paths.get("/rangeNotSatisfiable").get("get").getResponse(RangeNotSatisfiable.CODE).getDescription());
		assertEquals(RequestHeaderFieldsTooLarge.MESSAGE, paths.get("/requestHeaderFieldsTooLarge").get("get").getResponse(RequestHeaderFieldsTooLarge.CODE).getDescription());
		assertEquals(ServiceUnavailable.MESSAGE, paths.get("/serviceUnavailable").get("get").getResponse(ServiceUnavailable.CODE).getDescription());
		assertEquals(TooManyRequests.MESSAGE, paths.get("/tooManyRequests").get("get").getResponse(TooManyRequests.CODE).getDescription());
		assertEquals(Unauthorized.MESSAGE, paths.get("/unauthorized").get("get").getResponse(Unauthorized.CODE).getDescription());
		assertEquals(UnavailableForLegalReasons.MESSAGE, paths.get("/unavailableForLegalReasons").get("get").getResponse(UnavailableForLegalReasons.CODE).getDescription());
		assertEquals(UnprocessableEntity.MESSAGE, paths.get("/unprocessableEntity").get("get").getResponse(UnprocessableEntity.CODE).getDescription());
		assertEquals(UnsupportedMediaType.MESSAGE, paths.get("/unsupportedMediaType").get("get").getResponse(UnsupportedMediaType.CODE).getDescription());
		assertEquals(UpgradeRequired.MESSAGE, paths.get("/upgradeRequired").get("get").getResponse(UpgradeRequired.CODE).getDescription());
		assertEquals(UriTooLong.MESSAGE, paths.get("/uriTooLong").get("get").getResponse(UriTooLong.CODE).getDescription());
		assertEquals(VariantAlsoNegotiates.MESSAGE, paths.get("/variantAlsoNegotiates").get("get").getResponse(VariantAlsoNegotiates.CODE).getDescription());
	}

	//-----------------------------------------------------------------------------------------------------------------
	// Thrown object doesn't match return type.
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class G {
		@RestMethod
		public SeeOtherRoot a() throws Exception { throw new NotFound(); }
	}

	@Test
	public void g01_thrownObjectDoesntMatchReturnType() throws Exception {
		RestClient g = MockRestClient.buildLax(G.class);
		g.get("/a")
			.run()
			.assertCode().is(404);
	}

	//-----------------------------------------------------------------------------------------------------------------
	// ParseException should produce BadRequest
	//-----------------------------------------------------------------------------------------------------------------

	@Rest
	public static class H {
		@RestMethod
		public void a() throws Exception {
			throw new ParseException("Test");
		}
	}

	@Test
	public void h01_parseExceptionCausesBadRequest() throws Exception {
		RestClient h = MockRestClient.buildLax(H.class);
		h.get("/a")
			.run()
			.assertCode().is(400);
	}
}