[#BloombergLP-bslx-TestInStream]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslx.adoc[bslx]::TestInStream
:relfileprefix: ../../
:mrdocs:

This class provides input methods to unexternalize values, and C‐style arrays of values, of fundamental types from their byte representations. Each input method also verifies the input value type. By default, if invalid data is detected, error messages are displayed on `stdout`; this error reporting may be disabled via the `setQuiet` method. Note that attempting to read beyond the end of a stream will automatically invalidate the stream. See the `bslx` package‐level documentation for the definition of the BDEX `InStream` protocol.

== Synopsis

Declared in `<bslx_testinstream.h>`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
class TestInStream;
----

== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslx/TestInStream/2constructor-073.adoc[`TestInStream`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bslx/TestInStream/2destructor.adoc[`~TestInStream`] [.small]#[destructor]#
| Destroy this test input stream.
| xref:BloombergLP/bslx/TestInStream/cursor.adoc[`cursor`] 
| Return the index of the next byte to be extracted from this stream.
| xref:BloombergLP/bslx/TestInStream/data.adoc[`data`] 
| Return the address of the contiguous, non‐modifiable external memory buffer of this stream. The behavior of accessing elements outside the range `[ data() .. data() + (length() ‐ 1) ]` is undefined.
| xref:BloombergLP/bslx/TestInStream/getArrayFloat32.adoc[`getArrayFloat32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE single‐precision (4‐byte) floating‐point array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity. Note that for non‐conforming platforms, this operation may be lossy.
| xref:BloombergLP/bslx/TestInStream/getArrayFloat64.adoc[`getArrayFloat64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE double‐precision (8‐byte) floating‐point array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity. Note that for non‐conforming platforms, this operation may be lossy.
| xref:BloombergLP/bslx/TestInStream/getArrayInt16.adoc[`getArrayInt16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 16‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt24.adoc[`getArrayInt24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 24‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt32.adoc[`getArrayInt32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 32‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt40.adoc[`getArrayInt40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 40‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt48.adoc[`getArrayInt48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 48‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt56.adoc[`getArrayInt56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 56‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt64.adoc[`getArrayInt64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 64‐bit signed integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayInt8-07.adoc[`getArrayInt8`] 
| `getArrayInt8` overloads
| xref:BloombergLP/bslx/TestInStream/getArrayUint16.adoc[`getArrayUint16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 16‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint24.adoc[`getArrayUint24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 24‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint32.adoc[`getArrayUint32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 32‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint40.adoc[`getArrayUint40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 40‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint48.adoc[`getArrayUint48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 48‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint56.adoc[`getArrayUint56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 56‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint64.adoc[`getArrayUint64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 64‐bit unsigned integer array value into the specified `variables` of the specified `numVariables` if its type and length are appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variables` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variables` is undefined. The behavior is undefined unless `0 <= numVariables` and `variables` has sufficient capacity.
| xref:BloombergLP/bslx/TestInStream/getArrayUint8-0d.adoc[`getArrayUint8`] 
| `getArrayUint8` overloads
| xref:BloombergLP/bslx/TestInStream/getFloat32.adoc[`getFloat32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE single‐precision (4‐byte) floating‐point value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined. Note that for non‐conforming platforms, this operation may be lossy.
| xref:BloombergLP/bslx/TestInStream/getFloat64.adoc[`getFloat64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that IEEE double‐precision (8‐byte) floating‐point value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined. Note that for non‐conforming platforms, this operation may be lossy.
| xref:BloombergLP/bslx/TestInStream/getInt16.adoc[`getInt16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 16‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt24.adoc[`getInt24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 24‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt32.adoc[`getInt32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 32‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt40.adoc[`getInt40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 40‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt48.adoc[`getInt48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 48‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt56.adoc[`getInt56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 56‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt64.adoc[`getInt64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 64‐bit signed integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getInt8-07.adoc[`getInt8`] 
| `getInt8` overloads
| xref:BloombergLP/bslx/TestInStream/getLength.adoc[`getLength`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 8‐bit unsigned integer or 32‐bit signed integer value representing a length (see the `bslx` package‐level documentation) into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. Consume an 8‐bit unsigned integer if the most significant bit of this byte is 0, otherwise consume a 32‐bit signed integer and set the most significant bit to zero in the resultant `variable`. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getString.adoc[`getString`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume a string from this input stream, assign that value to the specified `variable`, update the cursor location, and return a reference to this stream. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined. The string must be prefaced by a non‐negative integer indicating the number of characters composing the string. The behavior is undefined unless the length indicator is non‐negative.
| xref:BloombergLP/bslx/TestInStream/getUint16.adoc[`getUint16`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 16‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint24.adoc[`getUint24`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 24‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint32.adoc[`getUint32`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 32‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint40.adoc[`getUint40`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 40‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint48.adoc[`getUint48`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 48‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint56.adoc[`getUint56`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 56‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint64.adoc[`getUint64`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 64‐bit unsigned integer value into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/getUint8-0d.adoc[`getUint8`] 
| `getUint8` overloads
| xref:BloombergLP/bslx/TestInStream/getVersion.adoc[`getVersion`] 
| If required, throw a `TestInStreamException` (see `throwExceptionIfInputLimitExhausted`); otherwise, consume the 8‐bit unsigned integer type code, verify the type of the next value in this stream, consume that 8‐bit unsigned integer value representing a version (see the `bslx` package‐level documentation) into the specified `variable` if its type is appropriate, update the cursor location, and return a reference to this stream. If the type is incorrect, then this stream is marked invalid and the value of `variable` is unchanged. If this stream is initially invalid, this operation has no effect. If this function otherwise fails to extract a valid value, this stream is marked invalid and the value of `variable` is undefined.
| xref:BloombergLP/bslx/TestInStream/inputLimit.adoc[`inputLimit`] 
| Return the current number of input requests left before an exception is thrown. A negative value indicates that no exception is scheduled.
| xref:BloombergLP/bslx/TestInStream/invalidate.adoc[`invalidate`] 
| Put this input stream in an invalid state. This function has no effect if this stream is already invalid. Note that this function should be called whenever a value extracted from this stream is determined to be invalid, inconsistent, or otherwise incorrect.
| xref:BloombergLP/bslx/TestInStream/isEmpty.adoc[`isEmpty`] 
| Return `true` if this stream is empty, and `false` otherwise. Note that this function enables higher‐level types to verify that, after successfully reading all expected data, no data remains.
| xref:BloombergLP/bslx/TestInStream/isQuiet.adoc[`isQuiet`] 
| Return `true` if this stream's quiet mode is ON, and `false` otherwise.
| xref:BloombergLP/bslx/TestInStream/isValid.adoc[`isValid`] 
| Return `true` if this stream is valid, and `false` otherwise. An invalid stream is a stream in which insufficient or invalid data was detected during an extraction operation. Note that an empty stream will be valid unless an extraction attempt or explicit invalidation causes it to be otherwise.
| xref:BloombergLP/bslx/TestInStream/length.adoc[`length`] 
| Return the total number of bytes stored in the external memory buffer.
| xref:BloombergLP/bslx/TestInStream/reset-0a.adoc[`reset`] 
| `reset` overloads
| xref:BloombergLP/bslx/TestInStream/seek.adoc[`seek`] 
| Set the index of the next byte to be extracted from this stream to the specified `offset` from the beginning of the stream, and validate this stream if it is currently invalid. The behavior is undefined unless `offset <= length()`.
| xref:BloombergLP/bslx/TestInStream/setInputLimit.adoc[`setInputLimit`] 
| Set the number of input operations allowed on this stream to the specified `limit` before an exception is thrown. If `limit` is less than 0, no exception is to be thrown. By default, no exception is scheduled.
| xref:BloombergLP/bslx/TestInStream/setQuiet.adoc[`setQuiet`] 
| Set the quiet mode for this test stream to the specified (boolean) `flagValue`. If `flagValue` is `true`, then quiet mode is turned ON and no error messages will be written to standard output. If `flagValue` is `false`, then quiet mode is turned OFF. Note that quiet mode is turned OFF by default.
| xref:BloombergLP/bslx/TestInStream/2conversion.adoc[`operator void const*`] 
| Return a non‐zero value if this stream is valid, and 0 otherwise. An invalid stream is a stream for which an input operation was detected to have failed.
|===


== Friends

[cols="1,4"]
|===
| Name| Description
| `xref:BloombergLP/bslx/operator_lshift-0a1.adoc[BloombergLP::bslx::operator<<]`
| Write the specified `object` to the specified output `stream` in some reasonable (multi‐line) format, and return a reference to `stream`.
|===

== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslx/operator_rshift-0c.adoc[`operator>>`]
| Read the specified `value` from the specified input `stream` following the requirements of the BDEX protocol (see the `bslx` package‐level documentation), and return a reference to `stream`. The behavior is undefined unless `TYPE` is BDEX‐compliant.
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#