check if pledgeinsize is defined

Author: nhz2

src/compression.jl

@@ -184,21 +184,23 @@ function TranscodingStreams.startproc(codec::ZstdCompressor, mode::Symbol, err::
     return :ok
 end
 
-function TranscodingStreams.pledgeinsize(codec::ZstdCompressor, insize::Int64, error::Error)::Symbol
-    if codec.cstream.ptr == C_NULL
-        Base.error("`startproc` must be called before `pledgeinsize`")
-    end
-    srcsize = if signbit(insize)
-        ZSTD_CONTENTSIZE_UNKNOWN
-    else
-        Culonglong(insize)
-    end
-    code = LibZstd.ZSTD_CCtx_setPledgedSrcSize(codec.cstream, srcsize)
-    if iserror(code)
-        error[] = ErrorException("zstd error setting pledged source size")
-        :error
-    else
-        :ok
+@static if isdefined(TranscodingStreams, :pledgeinsize) # Defined in v0.11.3
+    function TranscodingStreams.pledgeinsize(codec::ZstdCompressor, insize::Int64, err::Error)::Symbol
+        if codec.cstream.ptr == C_NULL
+            error("`startproc` must be called before `pledgeinsize`")
+        end
+        srcsize = if signbit(insize)
+            ZSTD_CONTENTSIZE_UNKNOWN
+        else
+            Culonglong(insize)
+        end
+        code = LibZstd.ZSTD_CCtx_setPledgedSrcSize(codec.cstream, srcsize)
+        if iserror(code)
+            err[] = ErrorException("zstd error setting pledged source size")
+            :error
+        else
+            :ok
+        end
     end
 end
 

test/runtests.jl

@@ -164,62 +164,64 @@ include("utils.jl")
         @test CodecZstd.find_decompressed_size(v) == CodecZstd.ZSTD_CONTENTSIZE_ERROR
     end
 
-    @testset "pledgeinsize" begin
-        # when pledgeinsize is available transcode should save the 
-        # decompressed size in a header
-        for n in [0:30; 1000; 1000000;]
-            v = transcode(ZstdCompressor, rand(UInt8, n))
-            @test CodecZstd.find_decompressed_size(v) == n
-        end
-
-        # Test what happens if pledgeinsize promise is broken
-        d1 = zeros(UInt8, 10000)
-        d2 = zeros(UInt8, 10000)
-        GC.@preserve d1 d2 begin
-            @testset "too many bytes" begin
-                m1 = TranscodingStreams.Memory(pointer(d1), 1000)
-                m2 = TranscodingStreams.Memory(pointer(d2), 1000)
-                codec = ZstdCompressor()
-                e = TranscodingStreams.Error()
-                @test TranscodingStreams.startproc(codec, :read, e) === :ok
-                @test TranscodingStreams.pledgeinsize(codec, Int64(10), e) === :ok
-                @test TranscodingStreams.process(codec, m1, m2, e) === (0, 0, :error)
-                @test e[] == ErrorException("zstd error: Src size is incorrect")
-                TranscodingStreams.finalize(codec)
-            end
-            @testset "too few bytes" begin
-                m1 = TranscodingStreams.Memory(pointer(d1), 10)
-                m2 = TranscodingStreams.Memory(pointer(d2), 1000)
-                codec = ZstdCompressor()
-                e = TranscodingStreams.Error()
-                @test TranscodingStreams.startproc(codec, :read, e) === :ok
-                @test TranscodingStreams.pledgeinsize(codec, Int64(10000), e) === :ok
-                @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
-                m1 = TranscodingStreams.Memory(pointer(d1), 0)
-                @test TranscodingStreams.process(codec, m1, m2, e)[3] === :error
-                @test e[] == ErrorException("zstd error: Src size is incorrect")
-                TranscodingStreams.finalize(codec)
-            end
-            @testset "set pledgeinsize after process" begin
-                m1 = TranscodingStreams.Memory(pointer(d1), 1000)
-                m2 = TranscodingStreams.Memory(pointer(d2), 1000)
-                codec = ZstdCompressor()
-                e = TranscodingStreams.Error()
-                @test TranscodingStreams.startproc(codec, :read, e) === :ok
-                @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
-                @test TranscodingStreams.pledgeinsize(codec, Int64(10000), e) === :error
-                @test e[] == ErrorException("zstd error setting pledged source size")
-                TranscodingStreams.finalize(codec)
+    if isdefined(TranscodingStreams, :pledgeinsize)
+        @testset "pledgeinsize" begin
+            # when pledgeinsize is available transcode should save the 
+            # decompressed size in a header
+            for n in [0:30; 1000; 1000000;]
+                v = transcode(ZstdCompressor, rand(UInt8, n))
+                @test CodecZstd.find_decompressed_size(v) == n
             end
-            @testset "set unknown pledgeinsize" begin
-                m1 = TranscodingStreams.Memory(pointer(d1), 1000)
-                m2 = TranscodingStreams.Memory(pointer(d2), 1000)
-                codec = ZstdCompressor()
-                e = TranscodingStreams.Error()
-                @test TranscodingStreams.startproc(codec, :read, e) === :ok
-                @test TranscodingStreams.pledgeinsize(codec, Int64(-1), e) === :ok
-                @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
-                TranscodingStreams.finalize(codec)
+
+            # Test what happens if pledgeinsize promise is broken
+            d1 = zeros(UInt8, 10000)
+            d2 = zeros(UInt8, 10000)
+            GC.@preserve d1 d2 begin
+                @testset "too many bytes" begin
+                    m1 = TranscodingStreams.Memory(pointer(d1), 1000)
+                    m2 = TranscodingStreams.Memory(pointer(d2), 1000)
+                    codec = ZstdCompressor()
+                    e = TranscodingStreams.Error()
+                    @test TranscodingStreams.startproc(codec, :read, e) === :ok
+                    @test TranscodingStreams.pledgeinsize(codec, Int64(10), e) === :ok
+                    @test TranscodingStreams.process(codec, m1, m2, e) === (0, 0, :error)
+                    @test e[] == ErrorException("zstd error: Src size is incorrect")
+                    TranscodingStreams.finalize(codec)
+                end
+                @testset "too few bytes" begin
+                    m1 = TranscodingStreams.Memory(pointer(d1), 10)
+                    m2 = TranscodingStreams.Memory(pointer(d2), 1000)
+                    codec = ZstdCompressor()
+                    e = TranscodingStreams.Error()
+                    @test TranscodingStreams.startproc(codec, :read, e) === :ok
+                    @test TranscodingStreams.pledgeinsize(codec, Int64(10000), e) === :ok
+                    @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
+                    m1 = TranscodingStreams.Memory(pointer(d1), 0)
+                    @test TranscodingStreams.process(codec, m1, m2, e)[3] === :error
+                    @test e[] == ErrorException("zstd error: Src size is incorrect")
+                    TranscodingStreams.finalize(codec)
+                end
+                @testset "set pledgeinsize after process" begin
+                    m1 = TranscodingStreams.Memory(pointer(d1), 1000)
+                    m2 = TranscodingStreams.Memory(pointer(d2), 1000)
+                    codec = ZstdCompressor()
+                    e = TranscodingStreams.Error()
+                    @test TranscodingStreams.startproc(codec, :read, e) === :ok
+                    @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
+                    @test TranscodingStreams.pledgeinsize(codec, Int64(10000), e) === :error
+                    @test e[] == ErrorException("zstd error setting pledged source size")
+                    TranscodingStreams.finalize(codec)
+                end
+                @testset "set unknown pledgeinsize" begin
+                    m1 = TranscodingStreams.Memory(pointer(d1), 1000)
+                    m2 = TranscodingStreams.Memory(pointer(d2), 1000)
+                    codec = ZstdCompressor()
+                    e = TranscodingStreams.Error()
+                    @test TranscodingStreams.startproc(codec, :read, e) === :ok
+                    @test TranscodingStreams.pledgeinsize(codec, Int64(-1), e) === :ok
+                    @test TranscodingStreams.process(codec, m1, m2, e)[3] === :ok
+                    TranscodingStreams.finalize(codec)
+                end
             end
         end
     end