1.16.7 [skip ci]

Co-authored-by: t-bltg <t-bltg@users.noreply.github.com>

.zenodo.json

@@ -688,6 +688,10 @@
             "name": "@t-bltg",
             "type": "Other"
         }
+        {
+            "name": "Fred Callaway",
+            "type": "Other"
+        }
     ],
     "upload_type": "software"
 }

Project.toml

@@ -1,7 +1,7 @@
 name = "Plots"
 uuid = "91a5bcdd-55d7-5caf-9e0b-520d859cae80"
 author = ["Tom Breloff (@tbreloff)"]
-version = "1.16.3"
+version = "1.16.7"
 
 [deps]
 Base64 = "2a0f44e3-6c83-55bd-87e4-b1978d98bd5f"

src/arg_desc.jl

@@ -141,6 +141,7 @@ const _arg_desc = KW(
                                 NTuple{2,Number} or Symbol. Force axis limits. Only finite values are used (you can set only the right limit with `xlims = (-Inf, 2)` for example).
                                 `:round` widens the limit to the nearest round number ie. [0.1,3.6]=>[0.0,4.0]
                                 `:symmetric` sets the limits to be symmetric around zero.
+                                Set widen=true to widen the specified limits (as occurs when lims are not specified).
                                 """,
 :ticks                       => "Vector of numbers (set the tick values), Tuple of (tickvalues, ticklabels), or `:auto`",
 :scale                       => "Symbol. Scale of the axis: `:none`, `:ln`, `:log2`, `:log10`",
@@ -177,6 +178,9 @@ const _arg_desc = KW(
 :minorgridlinewidth          => "Number. Width of the minor grid lines (in pixels)",
 :tick_direction              => "Symbol.  Direction of the ticks. `:in`, `:out` or `:none`",
 :showaxis                    => "Bool, Symbol or String.  Show the axis. `true`, `false`, `:show`, `:hide`, `:yes`, `:no`, `:x`, `:y`, `:z`, `:xy`, ..., `:all`, `:off`",
-:widen                       => "Bool. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders. Defaults to `true`.",
+:widen                       => """
+                                Bool or :auto. Widen the axis limits by a small factor to avoid cut-off markers and lines at the borders.
+                                Defaults to `:auto`, which widens unless limits were manually set.
+                                """,
 :draw_arrow                  => "Bool. Draw arrow at the end of the axis.",
 )

src/args.jl

@@ -476,7 +476,7 @@ const _axis_defaults = KW(
     :minorticks                  => false,
     :minorgrid                   => false,
     :showaxis                    => true,
-    :widen                       => true,
+    :widen                       => :auto,
     :draw_arrow                  => false,
 )
 

src/axes.jl

@@ -504,17 +504,19 @@ end
 const _widen_seriestypes = (:line, :path, :steppre, :stepmid, :steppost, :sticks, :scatter, :barbins, :barhist, :histogram, :scatterbins, :scatterhist, :stepbins, :stephist, :bins2d, :histogram2d, :bar, :shape, :path3d, :scatter3d)
 
 function default_should_widen(axis::Axis)
-    should_widen = false
-    if !(is_2tuple(axis[:lims]) || axis[:lims] == :round)
-        for sp in axis.sps
-            for series in series_list(sp)
-                if series.plotattributes[:seriestype] in _widen_seriestypes
-                    should_widen = true
-                end
+    if axis[:widen] isa Bool
+        return axis[:widen]
+    end
+    # automatic behavior: widen if limits aren't specified and series type is appropriate
+    (is_2tuple(axis[:lims]) || axis[:lims] == :round) && return false
+    for sp in axis.sps
+        for series in series_list(sp)
+            if series.plotattributes[:seriestype] in _widen_seriestypes
+                return true
             end
         end
     end
-    should_widen
+    false
 end
 
 function round_limits(amin,amax)
@@ -562,7 +564,7 @@ function axis_limits(sp, letter, should_widen = default_should_widen(sp[Symbol(l
         else
             amin, amax
         end
-    elseif should_widen && axis[:widen]
+    elseif should_widen
         widen(amin, amax, axis[:scale])
     elseif lims == :round
         round_limits(amin,amax)
@@ -701,62 +703,47 @@ function axis_drawing_info(sp, letter)
                 )
             end
         end
-        if !(ax[:ticks] in (:none, nothing, false))
+        if ax[:ticks] ∉ (:none, nothing, false)
             f = RecipesPipeline.scale_func(oax[:scale])
             invf = RecipesPipeline.inverse_scale_func(oax[:scale])
-            if ax[:tick_direction] !== :none
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.012 * (f(oamax) - f(oamin)))
-                    (-t, t)
-                else
-                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                    t = invf(f(oa1) + 0.012 * (f(oa2) - f(oa1)) * ticks_in)
-                    (oa1, t)
-                end
-            end
 
-            for tick in ticks[1]
-                if ax[:showaxis] && ax[:tick_direction] !== :none
-                    push!(
-                        tick_segments,
-                        reverse_if((tick, tick_start), isy),
-                        reverse_if((tick, tick_stop), isy),
-                    )
+            add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
+                if cond
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        t = invf(f(0) + factor * (f(oamax) - f(oamin)))
+                        (-t, t)
+                    else
+                        ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                        t = invf(f(oa1) + factor * (f(oa2) - f(oa1)) * ticks_in)
+                        (oa1, t)
+                    end
                 end
-                if ax[:grid]
-                    push!(
-                        grid_segments,
-                        reverse_if((tick, oamin), isy),
-                        reverse_if((tick, oamax), isy),
-                    )
-                end
-            end
 
-            if !(ax[:minorticks] in (:none, nothing, false)) || ax[:minorgrid]
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.006 * (f(oamax) - f(oamin)))
-                    (-t, t)
-                else
-                    t = invf(f(oa1) + 0.006 * (f(oa2) - f(oa1)) * ticks_in)
-                    (oa1, t)
-                end
-                for tick in minor_ticks
-                    if ax[:showaxis]
+                for tick in ticks
+                    if ax[:showaxis] && cond
                         push!(
                             tick_segments,
                             reverse_if((tick, tick_start), isy),
                             reverse_if((tick, tick_stop), isy),
                         )
                     end
-                    if ax[:minorgrid] 
+                    if grid
                         push!(
-                            minorgrid_segments,
+                            segments,
                             reverse_if((tick, oamin), isy),
                             reverse_if((tick, oamax), isy),
                         )
                     end
                 end
             end
+
+            # add major grid segments
+            add_major_or_minor_segments(ticks[1], ax[:grid], grid_segments, 0.012, ax[:tick_direction] !== :none)
+
+            # add minor grid segments
+            if ax[:minorticks] ∉ (:none, nothing, false) || ax[:minorgrid]
+                add_major_or_minor_segments(minor_ticks, ax[:minorgrid], minorgrid_segments, 0.006, true)
+            end
         end
     end
 
@@ -839,74 +826,54 @@ function axis_drawing_info_3d(sp, letter)
                 )
             end
         end
-        # TODO this can be simplified, we do almost the same thing twice for grid and minorgrid
-        if !(ax[:ticks] in (:none, nothing, false))
+
+        if ax[:ticks] ∉ (:none, nothing, false)
             f = RecipesPipeline.scale_func(nax[:scale])
             invf = RecipesPipeline.inverse_scale_func(nax[:scale])
-            if ax[:tick_direction] !== :none
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.012 * (f(namax) - f(namin)))
-                    (-t, t)
-                else
-                    ticks_in = ax[:tick_direction] == :out ? -1 : 1
-                    t = invf(f(na0) + 0.012 * (f(na1) - f(na0)) * ticks_in)
-                    (na0, t)
-                end
-            end
-
             ga0, ga1 = sp[:framestyle] in (:origin, :zerolines) ? (namin, namax) : (na0, na1)
-            for tick in ticks[1]
-                if ax[:showaxis] && ax[:tick_direction] !== :none
-                    push!(
-                        tick_segments,
-                        sort_3d_axes(tick, tick_start, fa0, letter),
-                        sort_3d_axes(tick, tick_stop, fa0, letter),
-                    )
-                end
-                if ax[:grid]
-                    push!(
-                        grid_segments,
-                        sort_3d_axes(tick, ga0, fa0, letter),
-                        sort_3d_axes(tick, ga1, fa0, letter),
-                    )
-                    push!(
-                        grid_segments,
-                        sort_3d_axes(tick, ga1, fa0, letter),
-                        sort_3d_axes(tick, ga1, fa1, letter),
-                    )
-                end
-            end
 
-            if !(ax[:minorticks] in (:none, nothing, false)) || ax[:minorgrid]
-                tick_start, tick_stop = if sp[:framestyle] == :origin
-                    t = invf(f(0) + 0.006 * (f(namax) - f(namin)))
-                    (-t, t)
-                else
-                    t = invf(f(na0) + 0.006 * (f(na1) - f(na0)) * ticks_in)
-                    (na0, t)
+            add_major_or_minor_segments(ticks, grid, segments, factor, cond) = begin
+                if cond
+                    tick_start, tick_stop = if sp[:framestyle] == :origin
+                        t = invf(f(0) + factor * (f(namax) - f(namin)))
+                        (-t, t)
+                    else
+                        ticks_in = ax[:tick_direction] == :out ? -1 : 1
+                        t = invf(f(na0) + factor * (f(na1) - f(na0)) * ticks_in)
+                        (na0, t)
+                    end
                 end
-                for tick in minor_ticks
-                    if ax[:showaxis] && ax[:tick_direction] !== :none
+
+                for tick in ticks
+                    if ax[:showaxis] && cond
                         push!(
                             tick_segments,
                             sort_3d_axes(tick, tick_start, fa0, letter),
                             sort_3d_axes(tick, tick_stop, fa0, letter),
                         )
                     end
-                    if ax[:minorgrid]
+                    if grid
                         push!(
-                            minorgrid_segments,
+                            segments,
                             sort_3d_axes(tick, ga0, fa0, letter),
                             sort_3d_axes(tick, ga1, fa0, letter),
                         )
                         push!(
-                            minorgrid_segments,
+                            segments,
                             sort_3d_axes(tick, ga1, fa0, letter),
                             sort_3d_axes(tick, ga1, fa1, letter),
                         )
                     end
                 end
             end
+
+            # add major grid segments
+            add_major_or_minor_segments(ticks[1], ax[:grid], grid_segments, 0.012, ax[:tick_direction] !== :none)
+
+            # add minor grid segments
+            if ax[:minorticks] ∉ (:none, nothing, false) || ax[:minorgrid]
+                add_major_or_minor_segments(minor_ticks, ax[:minorgrid], minorgrid_segments, 0.006, true)
+            end
         end
     end
 

src/backends/gr.jl

@@ -651,12 +651,17 @@ end
 
 function gr_set_tickfont(sp, letter)
     axis = sp[Symbol(letter, :axis)]
+
+    # invalidate alignment changes for small rotations (|θ| < 45°)
+    trigger(rot) = abs(sind(rot)) < abs(cosd(rot)) ? 0 : sign(rot)
+
+    rot = axis[:rotation]
     if letter === :x || (RecipesPipeline.is3d(sp) && letter === :y)
-        halign = (:left, :hcenter, :right)[sign(axis[:rotation]) + 2]
-        valign = (axis[:mirror] ? :bottom : :top)
+        halign = (:left, :hcenter, :right)[trigger(rot) + 2]
+        valign = (axis[:mirror] ? :bottom : :top, :vcenter)[trigger(abs(rot)) + 1]
     else
-        halign = (axis[:mirror] ? :left : :right)
-        valign = (:top, :vcenter, :bottom)[sign(axis[:rotation]) + 2]
+        halign = (axis[:mirror] ? :left : :right, :hcenter)[trigger(abs(rot)) + 1]
+        valign = (:top, :vcenter, :bottom)[trigger(rot) + 2]
     end
     gr_set_font(
         tickfont(axis),

src/backends/pgfplotsx.jl

@@ -1081,6 +1081,7 @@ end
 function pgfx_fillrange_series!(axis, series, series_func, i, fillrange, rng)
     fillrange_opt = PGFPlotsX.Options("line width" => "0", "draw opacity" => "0")
     fillrange_opt = merge(fillrange_opt, pgfx_fillstyle(series, i))
+    push!(fillrange_opt, "mark" => "none") # no markers on fillranges
     push!(fillrange_opt, "forget plot" => nothing)
     opt = series.plotattributes
     args = RecipesPipeline.is3d(series) ? (opt[:x][rng], opt[:y][rng], opt[:z][rng]) :

src/backends/plotly.jl

@@ -986,7 +986,7 @@ end
 
 
 function _show(io::IO, ::MIME"text/html", plt::Plot{PlotlyBackend})
-    write(io, standalone_html(plt))
+    write(io, embeddable_html(plt))
 end
 
 

src/backends/plotlyjs.jl

@@ -34,7 +34,7 @@ _show(io::IO, mime::MIME"application/vnd.plotly.v1+json", plt::Plot{PlotlyJSBack
 html_head(plt::Plot{PlotlyJSBackend}) = plotly_html_head(plt)
 html_body(plt::Plot{PlotlyJSBackend}) = plotly_html_body(plt)
 
-_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, standalone_html(plt))
+_show(io::IO, ::MIME"text/html", plt::Plot{PlotlyJSBackend}) = write(io, embeddable_html(plt))
 
 _display(plt::Plot{PlotlyJSBackend}) = display(plotlyjs_syncplot(plt))
 

src/backends/web.jl

@@ -19,6 +19,10 @@ function standalone_html(plt::AbstractPlot; title::AbstractString = get(plt.attr
     """
 end
 
+function embeddable_html(plt::AbstractPlot)
+    html_head(plt) * html_body(plt)
+end
+
 function open_browser_window(filename::AbstractString)
     @static if Sys.isapple()
         return run(`open $(filename)`)

src/components.jl

@@ -474,6 +474,11 @@ mutable struct SeriesAnnotations
     baseshape::Union{Shape, AbstractVector{Shape}, Nothing}
     scalefactor::Tuple
 end
+
+series_annotations(scalar) = series_annotations([scalar])
+function series_annotations(anns::AMat)
+  map(series_annotations, anns)
+end
 function series_annotations(strs::AbstractVector, args...)
     fnt = font()
     shp = nothing
@@ -570,6 +575,7 @@ end
 
 annotations(::Nothing) = []
 annotations(anns::AVec) = anns
+annotations(anns::AMat) = map(annotations, anns)
 annotations(anns) = Any[anns]
 annotations(sa::SeriesAnnotations) = sa
 

src/layouts.jl

@@ -406,7 +406,7 @@ end
 
 # ----------------------------------------------------------------------
 
-calc_num_subplots(layout::AbstractLayout) = 1
+calc_num_subplots(layout::AbstractLayout) = get(layout.attr, :blank, false) ? 0 : 1
 function calc_num_subplots(layout::GridLayout)
     tot = 0
     for l in layout.grid
@@ -775,9 +775,17 @@ end
 
 "Adds a new, empty subplot overlayed on top of `sp`, with a mirrored y-axis and linked x-axis."
 function twinx(sp::Subplot)
-    sp[:right_margin] = max(sp[:right_margin], 30px)
-    plot!(sp.plt, inset = (sp[:subplot_index], bbox(0,0,1,1)))
+    plot!(sp.plt,
+        inset = (sp[:subplot_index], bbox(0,0,1,1)),
+        right_margin = sp[:right_margin],
+        left_margin = sp[:left_margin],
+        top_margin = sp[:top_margin],
+        bottom_margin = sp[:bottom_margin],
+    )
     twinsp = sp.plt.subplots[end]
+    twinsp[:xaxis][:grid] = false
+    twinsp[:yaxis][:grid] = false
+    twinsp[:xaxis][:showaxis] = false
     twinsp[:yaxis][:mirror] = true
     twinsp[:background_color_inside] = RGBA{Float64}(0,0,0,0)
     link_axes!(sp[:xaxis], twinsp[:xaxis])

src/plot.jl

@@ -23,7 +23,38 @@ current(plot::AbstractPlot) = (CURRENT_PLOT.nullableplot = plot)
 
 Base.string(plt::Plot) = "Plot{$(plt.backend) n=$(plt.n)}"
 Base.print(io::IO, plt::Plot) = print(io, string(plt))
-Base.show(io::IO, plt::Plot) = print(io, string(plt))
+function Base.show(io::IO, plt::Plot)
+    print(io, string(plt))
+    sp_ekwargs = getindex.(plt.subplots, :extra_kwargs)
+    s_ekwargs = getindex.(plt.series_list, :extra_kwargs)
+    if isempty(plt[:extra_plot_kwargs]) && all(isempty, sp_ekwargs) && all(isempty, s_ekwargs)
+        return
+    end
+    print(io,"\nCaptured extra kwargs:\n")
+    do_show = true
+    for (key, value) in plt[:extra_plot_kwargs]
+        do_show && println(io, "  Plot:")
+        println(io, " "^4, key, ": ", value)
+        do_show = false
+    end
+    do_show = true
+    for (i, ekwargs) in enumerate(sp_ekwargs)
+        for (key, value) in ekwargs
+            do_show && println(io, "  SubplotPlot{$i}:")
+            println(io, " "^4, key, ": ", value)
+            do_show = false
+        end
+        do_show = true
+    end
+    for (i, ekwargs) in enumerate(s_ekwargs)
+        for (key, value) in ekwargs
+            do_show && println(io, "  Series{$i}:")
+            println(io, " "^4, key, ": ", value)
+            do_show = false
+        end
+        do_show = true
+    end
+end
 
 getplot(plt::Plot) = plt
 getattr(plt::Plot, idx::Int = 1) = plt.attr
@@ -60,7 +91,8 @@ end
 
 # build a new plot from existing plots
 # note: we split into plt1 and plts_tail so we can dispatch correctly
-function plot(plt1::Plot, plts_tail::Plot...; kw...)
+plot(plt1::Plot, plts_tail::Plot...; kw...) = plot!(deepcopy(plt1), deepcopy.(plts_tail)...; kw...)
+function plot!(plt1::Plot, plts_tail::Plot...; kw...)
     @nospecialize
     plotattributes = KW(kw)
     RecipesPipeline.preprocess_attributes!(plotattributes)

test/runtests.jl

@@ -1,4 +1,4 @@
-using Plots: guidefont
+using Plots: guidefont, series_annotations
 import ImageMagick
 using VisualRegressionTests
 using Plots

test/test_axes.jl

@@ -35,9 +35,31 @@ end
 @testset "Axis limits" begin
     pl = plot(1:5, xlims=:symmetric, widen = false)
     @test Plots.xlims(pl) == (-5, 5)
+
+    pl = plot(1:3)
+    @test Plots.xlims(pl) == Plots.widen(1,3)
+
+    pl = plot([1.05,2.0,2.95], ylims=:round)
+    @test Plots.ylims(pl) == (1, 3)
+
+    pl = plot(1:3, xlims=(1,5))
+    @test Plots.xlims(pl) == (1, 5)
+
+    pl = plot(1:3, xlims=(1,5), widen=true)
+    @test Plots.xlims(pl) == Plots.widen(1, 5)
 end
 
 @testset "3D Axis" begin
     ql = quiver([1, 2], [2, 1], [3, 4], quiver = ([1, -1], [0, 0], [1, -0.5]), arrow=true)
     @test ql[1][:projection] == "3d"
 end
+
+@testset "twinx" begin
+    pl = plot(1:10, margin = 2Plots.cm)
+    twpl = twinx(pl)
+    pl! = plot!(twinx(), -(1:10))
+    @test twpl[:right_margin] == 2Plots.cm
+    @test twpl[:left_margin] == 2Plots.cm
+    @test twpl[:top_margin] == 2Plots.cm
+    @test twpl[:bottom_margin] == 2Plots.cm
+end

test/test_components.jl

@@ -2,58 +2,58 @@ using Plots, Test
 
 @testset "Shapes" begin
     @testset "Type" begin
-        square = Shape([(0,0.0),(1,0.0),(1,1.0),(0,1.0)])
-        @test isa(square, Shape{Int64, Float64})
-        @test coords(square) isa Tuple{Vector{S}, Vector{T}} where {T,S}
+        square = Shape([(0, 0.0), (1, 0.0), (1, 1.0), (0, 1.0)])
+        @test isa(square, Shape{Int64,Float64})
+        @test coords(square) isa Tuple{Vector{S},Vector{T}} where {T,S}
     end
 
     @testset "Copy" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
         square2 = Shape(square)
         @test square2.x == square.x
         @test square2.y == square.y
     end
 
     @testset "Center" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
-        @test Plots.center(square) == (0.5,0.5)
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+        @test Plots.center(square) == (0.5, 0.5)
     end
 
     @testset "Translate" begin
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
-        squareUp = Shape([(0,1),(1,1),(1,2),(0,2)])
-        squareUpRight = Shape([(1,1),(2,1),(2,2),(1,2)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+        squareUp = Shape([(0, 1), (1, 1), (1, 2), (0, 2)])
+        squareUpRight = Shape([(1, 1), (2, 1), (2, 2), (1, 2)])
 
-        @test Plots.translate(square,0,1).x == squareUp.x
-        @test Plots.translate(square,0,1).y == squareUp.y
+        @test Plots.translate(square, 0, 1).x == squareUp.x
+        @test Plots.translate(square, 0, 1).y == squareUp.y
 
-        @test Plots.center(translate!(square,1)) == (1.5,1.5)
+        @test Plots.center(translate!(square, 1)) == (1.5, 1.5)
     end
 
     @testset "Rotate" begin
         # 2 radians rotation matrix
         R2 = [cos(2) sin(2); -sin(2) cos(2)]
         coords = [0 0; 1 0; 1 1; 0 1]'
-        coordsRotated2 = R2*(coords.-0.5).+0.5
+        coordsRotated2 = R2 * (coords .- 0.5) .+ 0.5
 
-        square = Shape([(0,0),(1,0),(1,1),(0,1)])
+        square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
 
         # make a new, rotated square
         square2 = Plots.rotate(square, -2)
-        @test square2.x ≈ coordsRotated2[1,:]
-        @test square2.y ≈ coordsRotated2[2,:]
+        @test square2.x ≈ coordsRotated2[1, :]
+        @test square2.y ≈ coordsRotated2[2, :]
 
         # unrotate the new square in place
         rotate!(square2, 2)
-        @test square2.x ≈ coords[1,:]
-        @test square2.y ≈ coords[2,:]
+        @test square2.x ≈ coords[1, :]
+        @test square2.y ≈ coords[2, :]
     end
 
     @testset "Plot" begin
         ang = range(0, 2π, length = 60)
-        ellipse(x, y, w, h) = Shape(w*sin.(ang).+x, h*cos.(ang).+y)
-        myshapes = [ellipse(x,rand(),rand(),rand()) for x = 1:4]
-        @test coords(myshapes) isa Tuple{Vector{Vector{S}}, Vector{Vector{T}}} where {T,S}
+        ellipse(x, y, w, h) = Shape(w * sin.(ang) .+ x, h * cos.(ang) .+ y)
+        myshapes = [ellipse(x, rand(), rand(), rand()) for x = 1:4]
+        @test coords(myshapes) isa Tuple{Vector{Vector{S}},Vector{Vector{T}}} where {T,S}
         local p
         @test_nowarn p = plot(myshapes)
         @test p[1][1][:seriestype] == :shape
@@ -62,7 +62,7 @@ end
 
 @testset "Brush" begin
     @testset "Colors" begin
-        baseline = brush(1, RGB(0,0,0))
+        baseline = brush(1, RGB(0, 0, 0))
         @test brush(:black) == baseline
         @test brush("black") == baseline
     end
@@ -76,7 +76,7 @@ end
     end
     @testset "Bad Argument" begin
         # using test_logs because test_warn seems to not work anymore
-        @test_logs (:warn,"Unused brush arg: nothing (Nothing)") begin
+        @test_logs (:warn, "Unused brush arg: nothing (Nothing)") begin
             brush(nothing)
         end
     end
@@ -84,44 +84,68 @@ end
 
 @testset "Fonts" begin
     @testset "Scaling" begin
-        sizesToCheck = [:titlefontsize, :legendfontsize, :legendtitlefontsize,
-            :xtickfontsize, :ytickfontsize, :ztickfontsize,
-            :xguidefontsize, :yguidefontsize, :zguidefontsize,]
+        sizesToCheck = [
+            :titlefontsize,
+            :legendfontsize,
+            :legendtitlefontsize,
+            :xtickfontsize,
+            :ytickfontsize,
+            :ztickfontsize,
+            :xguidefontsize,
+            :yguidefontsize,
+            :zguidefontsize,
+        ]
         # get inital font sizes
-        initialSizes = [Plots.default(s) for s in sizesToCheck ]
+        initialSizes = [Plots.default(s) for s in sizesToCheck]
 
         #scale up font sizes
         scalefontsizes(2)
 
         # get inital font sizes
-        doubledSizes = [Plots.default(s) for s in sizesToCheck ]
+        doubledSizes = [Plots.default(s) for s in sizesToCheck]
 
-        @test doubledSizes == initialSizes*2
+        @test doubledSizes == initialSizes * 2
 
         # reset font sizes
         resetfontsizes()
 
-        finalSizes = [Plots.default(s) for s in sizesToCheck ]
+        finalSizes = [Plots.default(s) for s in sizesToCheck]
 
         @test finalSizes == initialSizes
     end
 end
 
 @testset "Series Annotations" begin
-    square = Shape([(0,0),(1,0),(1,1),(0,1)])
-    @test_logs (:warn,"Unused SeriesAnnotations arg: triangle (Symbol)") begin
-        p = plot([1,2,3],
-            series_annotations=(["a"],
-                                 2,    # pass a scale factor
-                                 (1,4), # pass two scale factors (overwrites first one)
-                                 square, # pass a shape
-                                 font(:courier), # pass an annotation font
-                                 :triangle  # pass an incorrect argument
-                            ))
+    square = Shape([(0, 0), (1, 0), (1, 1), (0, 1)])
+    @test_logs (:warn, "Unused SeriesAnnotations arg: triangle (Symbol)") begin
+        p = plot(
+            [1, 2, 3],
+            series_annotations = (
+                ["a"],
+                2,    # pass a scale factor
+                (1, 4), # pass two scale factors (overwrites first one)
+                square, # pass a shape
+                font(:courier), # pass an annotation font
+                :triangle,  # pass an incorrect argument
+            ),
+        )
         sa = p.series_list[1].plotattributes[:series_annotations]
         @test sa.strs == ["a"]
         @test sa.font.family == "courier"
         @test sa.baseshape == square
-        @test sa.scalefactor == (1,4)
+        @test sa.scalefactor == (1, 4)
     end
+    spl = scatter(
+        4.53 .* [1/1 1/2 1/3 1/4 1/5],
+        [0 0 0 0 0],
+        layout = (5, 1),
+        ylims = (-1.1, 1.1),
+        xlims = (0, 5),
+        series_annotations = permutedims([["1/1"],["1/2"],["1/3"],["1/4"],["1/5"]]),
+    )
+    @test spl.series_list[1].plotattributes[:series_annotations].strs == ["1/1"]
+    @test spl.series_list[2].plotattributes[:series_annotations].strs == ["1/2"]
+    @test spl.series_list[3].plotattributes[:series_annotations].strs == ["1/3"]
+    @test spl.series_list[4].plotattributes[:series_annotations].strs == ["1/4"]
+    @test spl.series_list[5].plotattributes[:series_annotations].strs == ["1/5"]
 end