Add some more tests

docs/src/index.md

@@ -176,7 +176,8 @@ Hence, the value written to an `Auxiliary` may not be the same value when being
 - ¶ These are stored as `Int32` and `UInt32` for `Signed` and `Unsigned`, respectively.
 
 ### BAM element types
-The only different between SAM and BAM types is that the latter format permits different types of integers.
+#### BAM integers
+The main difference between SAM and BAM types is that the latter format permits different types of integers.
 Hence, except the types mentioned below, all the SAM types in the table above are also supported in BAM,
 with the same Julia <-> BAM type correspondance.
 Further, reading a value of `i` will return an `Int32` instead of an `Int`.
@@ -190,6 +191,17 @@ Further, reading a value of `i` will return an `Int32` instead of an `Int`.
 | `Unsigned` | `I`      | `UInt32`       |
 | `Signed`   | `i`      | `Int32`        |
 
+#### BAM Arrays
+Whereas reading a SAM array (type `B`) will result in a `Memory`, BAM arrays only promise
+that they return an `AbstractVector` of the correct element type:
+
+```jldoctest
+julia> aux = BAM.Auxiliary("ABBs\2\0\0\0\1\2\3\4");
+
+julia> aux["AB"] isa AbstractVector{Int16}
+true
+```
+
 ### The `Hex` type
 The SAM/BAM type `H` signifies a hex-encoded byte array.
 Byte arrays are stored as the `B:C` type when written, since this type is more legible (in SAM),

src/XAMAuxData.jl

@@ -73,10 +73,6 @@ get_type_tag(::Type{<:AbstractString}) = UInt8('Z')
 get_type_tag(::Type{<:AbstractVector}) = UInt8('B')
 get_type_tag(::Type{<:Hex}) = UInt8('H')
 
-function as_aux_type(T::Type{<:AUX_NUMBER_TYPES})
-    T != Union{} ? T : error("Cannot convert Union{} to XAM-compatible type")
-end
-
 as_aux_type(::Type{<:Real}) = Float32
 as_aux_type(::Type{<:Integer}) = Int32
 
@@ -170,18 +166,17 @@ function Base.isvalid(aux::AbstractAuxiliary)
     all(i -> !isa(i, Error), iter_encodings(aux))
 end
 
+function striptype end
 function Base.copy(aux::AbstractAuxiliary)
     x = aux.x
     v = if x isa Vector{UInt8}
         x[aux.start:end]
     else
         copy(MemoryView(aux))
     end
-    typeof(aux)(v, 1)
+    striptype(typeof(aux))(v, 1)
 end
 
-Base.empty(T::Type{<:AbstractAuxiliary{V}}) where V = T(empty(V), 1)
-
 function Base.length(aux::AbstractAuxiliary)::Int
     n = 0
     for val in iter_encodings(aux)

src/bam.jl

@@ -4,6 +4,7 @@ import ..AuxTag, ..AbstractAuxiliary, ..Hex
 import ..AUX_NUMBER_TYPES, ..try_auxtag, ..Error, ..Errors
 import ..is_printable, ..ELTYPE_DICT, ..load_hex, ..iter_encodings, ..AbstractEncodedIterator
 import ..is_printable_char, ..as_bam_aux_value, ..get_type_tag, ..hexencode!, ..AuxException
+import ..striptype
 
 public Auxiliary, AuxTag, Error, Errors
 
@@ -78,6 +79,9 @@ struct Auxiliary{T} <: AbstractAuxiliary{T}
     end
 end
 
+striptype(::Type{<:Auxiliary}) = Auxiliary
+Base.empty(::Type{Auxiliary}) = Auxiliary(UInt8[], 1)
+
 const MutableAuxiliary = Auxiliary{Vector{UInt8}}
 
 MemoryView(x::Auxiliary) = @inbounds MemoryView(x.x)[x.start:end]

src/sam.jl

@@ -12,7 +12,7 @@ module SAM
 import ..AuxTag, ..AbstractAuxiliary, ..ELTYPE_DICT, ..is_printable_char, ..is_printable, ..Hex, ..setindex_nonexisting!
 import ..DelimitedIterator, ..get_type_tag, ..Error, ..Errors, ..load_hex
 import ..try_auxtag, ..Unsafe, ..as_sam_aux_value, ..AUX_NUMBER_TYPES, ..hexencode!
-import ..iter_encodings, ..AbstractEncodedIterator, ..AuxException
+import ..iter_encodings, ..AbstractEncodedIterator, ..AuxException, ..striptype
 
 public Auxiliary, AuxTag, Hex, Errors, Error
 
@@ -115,6 +115,9 @@ struct Auxiliary{T <: AbstractVector{UInt8}} <: AbstractAuxiliary{T}
     end
 end
 
+striptype(::Type{<:Auxiliary}) = Auxiliary
+Base.empty(::Type{Auxiliary}) = Auxiliary(UInt8[], 1)
+
 const MutableAuxiliary = Auxiliary{Vector{UInt8}}
 
 function iter_encodings(aux::Auxiliary)

test/runtests.jl

@@ -1,6 +1,6 @@
 module XAMAuxDataTests
 
-using XAMAuxData: XAMAuxData, SAM, BAM, AuxTag, Hex, DelimitedIterator, Errors
+using XAMAuxData: XAMAuxData, SAM, BAM, AuxTag, Hex, DelimitedIterator, Errors, try_auxtag
 using Test
 using MemoryViews: MemoryView
 using FormatSpecimens
@@ -33,6 +33,14 @@ end
 
 @testset "AuxTag" begin
     @test AuxTag("ac") == AuxTag('a', 'c') == AuxTag(0x61, 0x63)
+    for good in ["AB", "A1", "a9", "w5"]
+        @test try_auxtag(good) isa AuxTag
+    end
+    for bad in ["", "A", "ABC", "A11", "5A", "AØ", "a!"]
+        @test try_auxtag(bad) === nothing
+    end
+
+    @test sort!(AuxTag.(["XA", "X1", "ab", "AB"])) == AuxTag.(["AB", "X1", "XA", "ab"])
 end
 
 @testset "SAM" begin
@@ -543,6 +551,24 @@ end # BAM
         @test aux["Kk"] == Float32.(mem)
     end
 
+    @testset "Arrays of non-basic types" begin
+        for T in [SAM.Auxiliary, BAM.Auxiliary]
+            aux = T(rand(UInt8, 10), 11)
+            inp = BigInt[20, -400, 102]
+            aux["AB"] = inp
+            outp = aux["AB"]
+            @test outp isa (T == SAM.Auxiliary ? Memory{Int32} : AbstractVector{Int32})
+            @test outp == inp
+
+            empty!(aux)
+            inp = [pi, MathConstants.e]
+            aux["KV"] = inp
+            outp = aux["KV"]
+            @test outp isa (T == SAM.Auxiliary ? Memory{Float32} : AbstractVector{Float32})
+            @test outp ≈ inp
+        end
+    end
+
     @testset "Bad arrays" begin
         for bad_eltype in [
             "W,1,2,3",
@@ -565,6 +591,46 @@ end # BAM
             aux = SAM.Auxiliary("AB:B:" * bad_array)
             @test aux["AB"] == Errors.InvalidArray
         end
+
+        for T in [SAM.Auxiliary, BAM.Auxiliary]
+            aux = T(UInt8[], 1)
+            @test_throws Exception aux["AB"] = Vector{Union{}}(undef, 3)
+        end
+    end
+end
+
+@testset "Various operations" begin
+    for T in [SAM.Auxiliary, BAM.Auxiliary]
+        aux = T(UInt8[], 1)
+        @test Dict(empty(T)) == Dict(aux)
+        @test length(aux) == 0
+        @test isempty(aux)
+        aux["k1"] = 1234
+        @test length(aux) == 1
+        @test !isempty(aux)
+        aux["v9"] = 'w'
+        @test length(aux) == 2
+        aux["AA"] = Int16[-500, 205, 1]
+        @test length(aux) == 3
+
+        for k in ["k1", "v9", "AA"]
+            @test haskey(aux, k)
+        end
+        @test collect(keys(aux)) == AuxTag.(["k1", "v9", "AA"])
+        for k in ["k2", "v7", "BB", "c1"]
+            @test !haskey(aux, k)
+        end
+
+        cp = copy(aux)
+        d = Dict(aux)
+        @test d == Dict(cp)
+        len = 3
+        for k in ["k1", "v9", "AA"]
+            delete!(aux, k)
+            len -= 1
+            @test length(aux) == len
+        end
+        @test Dict(cp) == d
     end
 end