Method syncDecompression

Tests/Libraries/AsyncStreams/ZLibStreamTest.cpp:137–176

    Span<char>       emptyOutput;
    Result           empty = compressor.process(source, emptyOutput);
    SC_TEST_EXPECT(not empty);
    SC_TEST_EXPECT(empty.errorValue() == static_cast<uint32_t>(AsyncStreamsError::CompressionOutputBufferEmpty));

    ZLibStream inflater;
    SC_TEST_EXPECT(inflater.init(ZLibStream::DecompressZLib));
    const char       invalidData[4] = {0, 0, 0, 0};
    Span<const char> invalidInput(invalidData);
    char             outputBytes[32];
    Span<char>       output(outputBytes);
    Result           invalid = inflater.process(invalidInput, output);
    SC_TEST_EXPECT(not invalid);
    SC_TEST_EXPECT(invalid.category() == AsyncStreamsResultCategory);
    SC_TEST_EXPECT(invalid.errorValue() == static_cast<uint32_t>(AsyncStreamsError::CompressionDataInvalid));

    char message[80];
    SC_TEST_EXPECT(formatAsyncStreamsError(invalid, message).status == ResultErrorFormatStatus::Success);

    ZLibStream invalidAlgorithm;
    Result     unsupported = invalidAlgorithm.init(static_cast<ZLibStream::Algorithm>(-1));
    SC_TEST_EXPECT(not unsupported);
    SC_TEST_EXPECT(unsupported.errorValue() == static_cast<uint32_t>(AsyncStreamsError::CompressionStreamInvalid));
}

void SC::ZLibStreamTest::uninitializedStream()
{
    ZLibStream       stream;
    char             inputByte[1] = {'x'};
    char             outputBytes[16];
    Span<const char> input(inputByte);
    Span<char>       output(outputBytes);
    Result           process = stream.process(input, output);
    SC_TEST_EXPECT(not process);
    SC_TEST_EXPECT(process.category() == AsyncStreamsResultCategory);
    SC_TEST_EXPECT(process.errorValue() == static_cast<uint32_t>(AsyncStreamsError::CompressionNotInitialized));

    bool   ended    = false;
    Result finalize = stream.finalize(output, ended);
    SC_TEST_EXPECT(not finalize);
    SC_TEST_EXPECT(finalize.category() == AsyncStreamsResultCategory);
    SC_TEST_EXPECT(finalize.errorValue() == static_cast<uint32_t>(AsyncStreamsError::CompressionNotInitialized));
}

void SC::ZLibStreamTest::syncCompression(ZLibStream::Algorithm compressionAlgorithm, const StringView inputString,