*scanner
	emitDepth     int
	maxDepth      int
	emitKV        bool
	emitRecursive bool
	objectAsKVS   bool

	depth   int
	scratch *scratch
	metaCh  chan *MetaValue
	err     error

	// follow line position to add context to errors
	lineNo    int
	lineStart int64
}

// NewDecoder creates new Decoder to read JSON values at the provided
// emitDepth from the provider io.Reader.

    with pytest.raises(ResponseValidationError) as err:
        client.get("/model/modelX")
    assert err.value.errors() == [
        {
            "type": "value_error",
            "loc": ("response", "name"),
            "msg": "Value error, name must end in A",
            "input": "modelX",
            "ctx": {"error": HasRepr("ValueError('name must end in A')")},
        }
    ]


def test_openapi_schema(client: TestClient):

     * best we can do (since logging may overflow the stack) is to let the error propagate. Because
     * it is an Error, it won't be caught and logged by AbstractFuture.executeListener. Instead, it
     * can propagate through many layers of AbstractTransformFuture up to the root call to set().
     *
     * https://github.com/google/guava/issues/2254
     *
     * Other kinds of Errors are possible:
     *

errors.failed_to_read_request_file=Fehler beim Lesen einer Anforderungsdatei: {0}
errors.invalid_header_for_request_file=Ungültige Header-Zeile: {0}
errors.could_not_delete_logged_in_user=Sie können keinen angemeldeten Benutzer löschen.
errors.unauthorized_request=Unautorisierte Anfrage.
errors.failed_to_print_thread_dump=Fehler beim Drucken eines Thread-Dumps.
errors.file_is_not_supported={0} wird nicht unterstützt.

}

// decodeVersions will decode a number of versions from a buffer
// and perform a callback for each version in order, newest first.
// Any non-nil error is returned.
func decodeVersions(buf []byte, versions int, fn func(idx int, hdr, meta []byte) error) (err error) {
	var tHdr, tMeta []byte // Zero copy bytes
	for i := range versions {
		tHdr, buf, err = msgp.ReadBytesZC(buf)
		if err != nil {
			return err
		}

                    new ProjectExecutionEvent(session, currentProject, t));

            // rethrow original errors and runtime exceptions
            if (t instanceof RuntimeException runtimeException) {
                throw runtimeException;
            }
            if (t instanceof Error error) {
                throw error;
            }
        } finally {
            session.setCurrentProject(null);

			want += int64(len(tmp) - len(after))

			return buf[:want], err

		default:
			return nil, errors.New("unknown minor metadata version")
		}
	default:
		return nil, errors.New("unknown major metadata version")
	}
}

func decodeXLHeaders(buf []byte) (versions int, headerV, metaV uint8, b []byte, err error) {
	hdrVer, buf, err := msgp.ReadUint8Bytes(buf)
	if err != nil {
		return 0, 0, 0, buf, err
	}

# Exceptions - `HTTPException` and `WebSocketException`

These are the exceptions that you can raise to show errors to the client.

When you raise an exception, as would happen with normal Python, the rest of the execution is aborted. This way you can raise these exceptions from anywhere in the code to abort a request and show the error to the client.

You can use:

* `HTTPException`
* `WebSocketException`

			if err != nil {
				t.Fatal(err)
			}

			errStr := ""
			err = checkPostPolicy(tt.fv.Header, postPolicyForm)
			if err != nil {
				errStr = err.Error()
			}
			if errStr != tt.wantErr {
				t.Errorf("test: '%s', want error: '%s', got error: '%s'", tt.name, tt.wantErr, errStr)
			}
		})
	}

        /**
         * Called when a witness registration fails.
         *
         * @param registration the failed registration
         * @param error the error that occurred
         */
        void onRegistrationFailed(WitnessRegistration registration, Exception error);

        /**
         * Called when a witness registration expires.
         *
         * @param registration the expired registration
         */