#37921

Committed 01 Oct 2024 06:56PM UTC coverage: 86.72% (-1.0%) from 87.726%

Build # #37921

Build Type

push

local

Committed by

web-flow

Commit Message

fix rounding mode in construction of `BigFloat` from pi (#55911)

The default argument of the method was outdated, reading the global
default rounding directly, bypassing the `ScopedValue` stuff.

Run Details

1 of 1 new or added line in 1 file covered. (100.0%)

1303 existing lines in 54 files now uncovered.

77739 of 89644 relevant lines covered (86.72%)

15942014.53 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/stdlib/Base64/src/encode.jl

# This file is a part of Julia. License is MIT: https://julialang.org/license

# Generate encode table.
const BASE64_ENCODE = [UInt8(x) for x in append!(['A':'Z'; 'a':'z'; '0':'9'], ['+', '/'])]
encode(x::UInt8) = @inbounds return BASE64_ENCODE[(x & 0x3f) + 1]
encodepadding()  = UInt8('=')

"""
    Base64EncodePipe(ostream)

Return a new write-only I/O stream, which converts any bytes written to it into
base64-encoded ASCII bytes written to `ostream`.  Calling [`close`](@ref) on the
`Base64EncodePipe` stream is necessary to complete the encoding (but does not
close `ostream`).

# Examples
```jldoctest
julia> io = IOBuffer();

julia> iob64_encode = Base64EncodePipe(io);

julia> write(iob64_encode, "Hello!")
6

julia> close(iob64_encode);

julia> str = String(take!(io))
"SGVsbG8h"

julia> String(base64decode(str))
"Hello!"
```
"""
struct Base64EncodePipe <: IO
    io::IO
    buffer::Buffer

    function Base64EncodePipe(io::IO)
        # The buffer size must be at least 3.
        buffer = Buffer(512)
        pipe = new(io, buffer)
        finalizer(_ -> close(pipe), buffer)
        return pipe
    end
end

Base.isreadable(::Base64EncodePipe) = false
Base.iswritable(pipe::Base64EncodePipe) = iswritable(pipe.io)

function Base.unsafe_write(pipe::Base64EncodePipe, ptr::Ptr{UInt8}, n::UInt)::Int
    buffer = pipe.buffer
    m = buffer.size
    b1, b2, b3, k = loadtriplet!(buffer, ptr, n)
    @assert k ≥ m
    p = ptr + k - m
    if k < 3
        if k == 1
            buffer[1] = b1
            buffer.size = 1
        elseif k == 2
            buffer[1] = b1
            buffer[2] = b2
            buffer.size = 2
        end
        return p - ptr
    end
    @assert buffer.size == 0

    i = 0
    p_end = ptr + n
    while true
        buffer[i+1] = encode(b1 >> 2          )
        buffer[i+2] = encode(b1 << 4 | b2 >> 4)
        buffer[i+3] = encode(b2 << 2 | b3 >> 6)
        buffer[i+4] = encode(          b3     )
        i += 4
        if p + 2 < p_end
            b1 = unsafe_load(p, 1)
            b2 = unsafe_load(p, 2)
            b3 = unsafe_load(p, 3)
            p += 3
        else
            break
        end
        if i + 4 > capacity(buffer)
            unsafe_write(pipe.io, pointer(buffer), i)
            i = 0
        end
    end
    if i > 0
        unsafe_write(pipe.io, pointer(buffer), i)
    end

    while p < p_end
        buffer[buffer.size+=1] = unsafe_load(p)
        p += 1
    end
    return p - ptr
end

function Base.write(pipe::Base64EncodePipe, x::UInt8)
    buffer = pipe.buffer
    buffer[buffer.size+=1] = x
    if buffer.size == 3
        unsafe_write(pipe, C_NULL, 0)
    end
    return 1
end

function Base.close(pipe::Base64EncodePipe)
    b1, b2, b3, k = loadtriplet!(pipe.buffer, Ptr{UInt8}(C_NULL), UInt(0))
    if k == 0
        # no leftover and padding
    elseif k == 1
        write(pipe.io,
              encode(b1 >> 2),
              encode(b1 << 4),
              encodepadding(),
              encodepadding())
    elseif k == 2
        write(pipe.io,
              encode(          b1 >> 2),
              encode(b1 << 4 | b2 >> 4),
              encode(b2 << 2          ),
              encodepadding())
    else
        @assert k == 3
        write(pipe.io,
              encode(b1 >> 2          ),
              encode(b1 << 4 | b2 >> 4),
              encode(b2 << 2 | b3 >> 6),
              encode(          b3     ))
    end
    return nothing
end

# Load three bytes from buffer and ptr.
function loadtriplet!(buffer::Buffer, ptr::Ptr{UInt8}, n::UInt)
    b1 = b2 = b3 = 0x00
    if buffer.size == 0
        if n == 0
            k = 0
        elseif n == 1
            b1 = unsafe_load(ptr, 1)
            k = 1
        elseif n == 2
            b1 = unsafe_load(ptr, 1)
            b2 = unsafe_load(ptr, 2)
            k = 2
        else
            b1 = unsafe_load(ptr, 1)
            b2 = unsafe_load(ptr, 2)
            b3 = unsafe_load(ptr, 3)
            k = 3
        end
    elseif buffer.size == 1
        b1 = buffer[1]
        if n == 0
            k = 1
        elseif n == 1
            b2 = unsafe_load(ptr, 1)
            k = 2
        else
            b2 = unsafe_load(ptr, 1)
            b3 = unsafe_load(ptr, 2)
            k = 3
        end
    elseif buffer.size == 2
        b1 = buffer[1]
        b2 = buffer[2]
        if n == 0
            k = 2
        else
            b3 = unsafe_load(ptr, 1)
            k = 3
        end
    else
        @assert buffer.size == 3
        b1 = buffer[1]
        b2 = buffer[2]
        b3 = buffer[3]
        k = 3
    end
    empty!(buffer)
    return b1, b2, b3, k
end

"""
    base64encode(writefunc, args...; context=nothing)
    base64encode(args...; context=nothing)

Given a [`write`](@ref)-like function `writefunc`, which takes an I/O stream as
its first argument, `base64encode(writefunc, args...)` calls `writefunc` to
write `args...` to a base64-encoded string, and returns the string.
`base64encode(args...)` is equivalent to `base64encode(write, args...)`: it
converts its arguments into bytes using the standard [`write`](@ref) functions
and returns the base64-encoded string.

The optional keyword argument `context` can be set to `:key=>value` pair
or an `IO` or [`IOContext`](@ref) object whose attributes are used for the I/O
stream passed to `writefunc` or `write`.

See also [`base64decode`](@ref).
"""
function base64encode(f::Function, args...; context=nothing)
    s = IOBuffer()
    b = Base64EncodePipe(s)
    if context === nothing
        f(b, args...)
    else
        f(IOContext(b, context), args...)
    end
    close(b)
    return String(take!(s))
end
base64encode(args...; context=nothing) = base64encode(write, args...; context=context)

1	# This file is a part of Julia. License is MIT: https://julialang.org/license
2
3	# Generate encode table.
4	const BASE64_ENCODE = [UInt8(x) for x in append!(['A':'Z'; 'a':'z'; '0':'9'], ['+', '/'])]
UNCOV 5	encode(x::UInt8) = @inbounds return BASE64_ENCODE[(x & 0x3f) + 1]	×
6	encodepadding() = UInt8('=')	×
7
8	"""
9	Base64EncodePipe(ostream)
10
11	Return a new write-only I/O stream, which converts any bytes written to it into
12	base64-encoded ASCII bytes written to `ostream`. Calling [`close`](@ref) on the
13	`Base64EncodePipe` stream is necessary to complete the encoding (but does not
14	close `ostream`).
15
16	# Examples
17	```jldoctest
18	julia> io = IOBuffer();
19
20	julia> iob64_encode = Base64EncodePipe(io);
21
22	julia> write(iob64_encode, "Hello!")
23	6
24
25	julia> close(iob64_encode);
26
27	julia> str = String(take!(io))
28	"SGVsbG8h"
29
30	julia> String(base64decode(str))
31	"Hello!"
32	```
33	"""
34	struct Base64EncodePipe <: IO
35	io::IO
36	buffer::Buffer
37
38	function Base64EncodePipe(io::IO)
39	# The buffer size must be at least 3.
UNCOV 40	buffer = Buffer(512)	×
UNCOV 41	pipe = new(io, buffer)	×
UNCOV 42	finalizer(_ -> close(pipe), buffer)	×
UNCOV 43	return pipe	×
44	end
45	end
46
47	Base.isreadable(::Base64EncodePipe) = false	×
UNCOV 48	Base.iswritable(pipe::Base64EncodePipe) = iswritable(pipe.io)	×
49
UNCOV 50	function Base.unsafe_write(pipe::Base64EncodePipe, ptr::Ptr{UInt8}, n::UInt)::Int	×
UNCOV 51	buffer = pipe.buffer	×
UNCOV 52	m = buffer.size	×
UNCOV 53	b1, b2, b3, k = loadtriplet!(buffer, ptr, n)	×
UNCOV 54	@assert k ≥ m	×
UNCOV 55	p = ptr + k - m	×
UNCOV 56	if k < 3	×
UNCOV 57	if k == 1	×
UNCOV 58	buffer[1] = b1	×
UNCOV 59	buffer.size = 1	×
UNCOV 60	elseif k == 2	×
UNCOV 61	buffer[1] = b1	×
UNCOV 62	buffer[2] = b2	×
UNCOV 63	buffer.size = 2	×
64	end
UNCOV 65	return p - ptr	×
66	end
UNCOV 67	@assert buffer.size == 0	×
68
UNCOV 69	i = 0	×
UNCOV 70	p_end = ptr + n	×
UNCOV 71	while true	×
UNCOV 72	buffer[i+1] = encode(b1 >> 2 )	×
UNCOV 73	buffer[i+2] = encode(b1 << 4 \| b2 >> 4)	×
UNCOV 74	buffer[i+3] = encode(b2 << 2 \| b3 >> 6)	×
UNCOV 75	buffer[i+4] = encode( b3 )	×
UNCOV 76	i += 4	×
UNCOV 77	if p + 2 < p_end	×
UNCOV 78	b1 = unsafe_load(p, 1)	×
UNCOV 79	b2 = unsafe_load(p, 2)	×
UNCOV 80	b3 = unsafe_load(p, 3)	×
UNCOV 81	p += 3	×
82	else
UNCOV 83	break	×
84	end
UNCOV 85	if i + 4 > capacity(buffer)	×
86	unsafe_write(pipe.io, pointer(buffer), i)	×
87	i = 0	×
88	end
UNCOV 89	end	×
UNCOV 90	if i > 0	×
UNCOV 91	unsafe_write(pipe.io, pointer(buffer), i)	×
92	end
93
UNCOV 94	while p < p_end	×
UNCOV 95	buffer[buffer.size+=1] = unsafe_load(p)	×
UNCOV 96	p += 1	×
UNCOV 97	end	×
UNCOV 98	return p - ptr	×
99	end
100
UNCOV 101	function Base.write(pipe::Base64EncodePipe, x::UInt8)	×
UNCOV 102	buffer = pipe.buffer	×
UNCOV 103	buffer[buffer.size+=1] = x	×
UNCOV 104	if buffer.size == 3	×
UNCOV 105	unsafe_write(pipe, C_NULL, 0)	×
106	end
UNCOV 107	return 1	×
108	end
109
UNCOV 110	function Base.close(pipe::Base64EncodePipe)	×
UNCOV 111	b1, b2, b3, k = loadtriplet!(pipe.buffer, Ptr{UInt8}(C_NULL), UInt(0))	×
UNCOV 112	if k == 0	×
113	# no leftover and padding
UNCOV 114	elseif k == 1	×
UNCOV 115	write(pipe.io,	×
116	encode(b1 >> 2),
117	encode(b1 << 4),
118	encodepadding(),
119	encodepadding())
UNCOV 120	elseif k == 2	×
UNCOV 121	write(pipe.io,	×
122	encode( b1 >> 2),
123	encode(b1 << 4 \| b2 >> 4),
124	encode(b2 << 2 ),
125	encodepadding())
126	else
127	@assert k == 3	×
128	write(pipe.io,	×
129	encode(b1 >> 2 ),
130	encode(b1 << 4 \| b2 >> 4),
131	encode(b2 << 2 \| b3 >> 6),
132	encode( b3 ))
133	end
UNCOV 134	return nothing	×
135	end
136
137	# Load three bytes from buffer and ptr.
138	function loadtriplet!(buffer::Buffer, ptr::Ptr{UInt8}, n::UInt)
UNCOV 139	b1 = b2 = b3 = 0x00	×
UNCOV 140	if buffer.size == 0	×
UNCOV 141	if n == 0	×
UNCOV 142	k = 0	×
UNCOV 143	elseif n == 1	×
UNCOV 144	b1 = unsafe_load(ptr, 1)	×
UNCOV 145	k = 1	×
UNCOV 146	elseif n == 2	×
UNCOV 147	b1 = unsafe_load(ptr, 1)	×
UNCOV 148	b2 = unsafe_load(ptr, 2)	×
UNCOV 149	k = 2	×
150	else
UNCOV 151	b1 = unsafe_load(ptr, 1)	×
UNCOV 152	b2 = unsafe_load(ptr, 2)	×
UNCOV 153	b3 = unsafe_load(ptr, 3)	×
UNCOV 154	k = 3	×
155	end
UNCOV 156	elseif buffer.size == 1	×
UNCOV 157	b1 = buffer[1]	×
UNCOV 158	if n == 0	×
UNCOV 159	k = 1	×
160	elseif n == 1	×
161	b2 = unsafe_load(ptr, 1)	×
162	k = 2	×
163	else
164	b2 = unsafe_load(ptr, 1)	×
165	b3 = unsafe_load(ptr, 2)	×
166	k = 3	×
167	end
UNCOV 168	elseif buffer.size == 2	×
UNCOV 169	b1 = buffer[1]	×
UNCOV 170	b2 = buffer[2]	×
UNCOV 171	if n == 0	×
UNCOV 172	k = 2	×
173	else
174	b3 = unsafe_load(ptr, 1)	×
175	k = 3	×
176	end
177	else
UNCOV 178	@assert buffer.size == 3	×
UNCOV 179	b1 = buffer[1]	×
UNCOV 180	b2 = buffer[2]	×
UNCOV 181	b3 = buffer[3]	×
UNCOV 182	k = 3	×
183	end
UNCOV 184	empty!(buffer)	×
UNCOV 185	return b1, b2, b3, k	×
186	end
187
188	"""
189	base64encode(writefunc, args...; context=nothing)
190	base64encode(args...; context=nothing)
191
192	Given a [`write`](@ref)-like function `writefunc`, which takes an I/O stream as
193	its first argument, `base64encode(writefunc, args...)` calls `writefunc` to
194	write `args...` to a base64-encoded string, and returns the string.
195	`base64encode(args...)` is equivalent to `base64encode(write, args...)`: it
196	converts its arguments into bytes using the standard [`write`](@ref) functions
197	and returns the base64-encoded string.
198
199	The optional keyword argument `context` can be set to `:key=>value` pair
200	or an `IO` or [`IOContext`](@ref) object whose attributes are used for the I/O
201	stream passed to `writefunc` or `write`.
202
203	See also [`base64decode`](@ref).
204	"""
UNCOV 205	function base64encode(f::Function, args...; context=nothing)	×
UNCOV 206	s = IOBuffer()	×
UNCOV 207	b = Base64EncodePipe(s)	×
UNCOV 208	if context === nothing	×
UNCOV 209	f(b, args...)	×
210	else
211	f(IOContext(b, context), args...)	×
212	end
UNCOV 213	close(b)	×
UNCOV 214	return String(take!(s))	×
215	end
UNCOV 216	base64encode(args...; context=nothing) = base64encode(write, args...; context=context)	×

JuliaLang / julia / #37921

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous