Package evaluation of BaseInterfaces on Julia 1.11.4 (a71dd056e0*) started at 2025-04-08T07:18:03.604 ################################################################################ # Set-up # Installing PkgEval dependencies (TestEnv)... Set-up completed after 8.48s ################################################################################ # Installation # Installing BaseInterfaces... Resolving package versions... Updating `~/.julia/environments/v1.11/Project.toml` [0b829d9d] + BaseInterfaces v0.1.0 Updating `~/.julia/environments/v1.11/Manifest.toml` [0b829d9d] + BaseInterfaces v0.1.0 [85a1e053] + Interfaces v0.3.2 Installation completed after 1.05s ################################################################################ # Precompilation # Precompiling PkgEval dependencies... Precompiling package dependencies... Precompilation completed after 14.16s ################################################################################ # Testing # Testing BaseInterfaces Status `/tmp/jl_eVR9Ku/Project.toml` [0b829d9d] BaseInterfaces v0.1.0 [85a1e053] Interfaces v0.3.2 [8dfed614] Test v1.11.0 Status `/tmp/jl_eVR9Ku/Manifest.toml` [0b829d9d] BaseInterfaces v0.1.0 [85a1e053] Interfaces v0.3.2 [2a0f44e3] Base64 v1.11.0 [b77e0a4c] InteractiveUtils v1.11.0 [56ddb016] Logging v1.11.0 [d6f4376e] Markdown v1.11.0 [9a3f8284] Random v1.11.0 [ea8e919c] SHA v0.7.0 [9e88b42a] Serialization v1.11.0 [8dfed614] Test v1.11.0 Testing Running tests... Testing SetInterface is implemented for BitSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for GenericSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing SetInterface is implemented for Set Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for IdSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing IterationInterface is implemented for Number Mandatory components isempty: test iterator is not empty [true, true, true, true, true] iterate: (`iterate` does not return `nothing` [true, true, true, true, true], `iterate` returns a `Tuple` [true, true, true, true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true, true, true, true]) isiterable: [true, true, true, true, true] eltype: values of `x` are `<: eltype(x)` [true, true, true, true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true, true, true, true] Testing SetInterface is implemented for Base.KeySet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing IterationInterface is implemented for Array Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Pair Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Set Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Dict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Base.ImmutableDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for NamedTuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for UnitRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Base.Generator Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] Testing IterationInterface is implemented for BitSet Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for StepRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Tuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for String Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Base.EnvDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing ArrayInterface is implemented for PermutedDimsArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for BitArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true] Testing ArrayInterface is implemented for Array Mandatory components eltype: ([true, true], [true, true]) ndims: ([true, true], [true, true]) size: (size(A) returns a tuple of Integer [true, true], length of size(A) matches ndims(A) [true, true]) getindex: (Can index with begin/firstindex [true, true], Can index with end/lastindex [true, true], Can index with all indices in `eachindex(A)` [true, true], Can index with Int for multiple dimensions [true, true], Can index with Int for multiple dimensions and trailing ones [true, true], Can index with Int for multiple dimensions and trailing colons [true, true], Can index with CartesianIndex [true, true], Can index with CartesianIndex and trailing ones [true, true], Can index with CartesianIndices [true, true], Can index with CartesianIndices and trailing ones [true, true], Can index with CartesianIndices and trailing colons [true, true], Can index with UnitRange [true, true], Can index with UnitRange and trailing ones [true, true], Can index with UnitRange and trailing colons [true, true], Can index with StepRange [true, true], Can index with StepRange and trailing ones [true, true], Can index with StepRange and trailing colons [true, true], Can index with a Vector of Int [true, true], Can index with a Vector of Int32 [true, true], Can index with a Vector of Int with trailing ones [true, true], Can index with a Vector of Int with trailing colons [true, true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true, true] Optional components logical: (Can index with logical indices [true, true], Can index with logical indices and trailing ones [true, true], Can index with logical indices and trailing colons [true, true], Can index with multidimensional logical indices [true, true], Can index with multidimensional logical indices and trailing ones [true, true], Can index with multidimensional logical indices and trailing colons [true, true]) setindex!: (Bool[1, 1], Pair{String, Bool}["setindex! can write the first to the last element" => 1, "setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1, "setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1, "setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1, "setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true, true] similar_eltype: similar(A, T::Type) returns an object the same base type as `A` with eltype of `T` [true, true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true, true] Testing ArrayInterface is implemented for Base.OneTo Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for Base.CodeUnits Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for SubArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for Base.ReshapedArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for UnitRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for StepRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing DictInterface is implemented for Base.Pairs Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Base.ImmutableDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for IdDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Dict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Base.EnvDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for GenericDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing StringInterface is implemented for SubString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for SubstitutionString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for GenericString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Testing StringInterface is implemented for String Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for LazyString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Implementation summary: BitSet correctly implements SetInterface: true GenericSet correctly implements SetInterface: true Set correctly implements SetInterface: true IdSet correctly implements SetInterface: true Number correctly implements IterationInterface: true Base.KeySet correctly implements SetInterface: true Array correctly implements IterationInterface: true Pair correctly implements IterationInterface: true Set correctly implements IterationInterface: true Dict correctly implements IterationInterface: true Base.ImmutableDict correctly implements IterationInterface: true NamedTuple correctly implements IterationInterface: true UnitRange correctly implements IterationInterface: true Base.Generator correctly implements IterationInterface: true BitSet correctly implements IterationInterface: true StepRange correctly implements IterationInterface: true Tuple correctly implements IterationInterface: true String correctly implements IterationInterface: true Base.EnvDict correctly implements IterationInterface: true PermutedDimsArray correctly implements ArrayInterface: true BitArray correctly implements ArrayInterface: true Array correctly implements ArrayInterface: true Base.OneTo correctly implements ArrayInterface: true Base.CodeUnits correctly implements ArrayInterface: true SubArray correctly implements ArrayInterface: true Base.ReshapedArray correctly implements ArrayInterface: true UnitRange correctly implements ArrayInterface: true StepRange correctly implements ArrayInterface: true Base.Pairs correctly implements DictInterface: true Base.ImmutableDict correctly implements DictInterface: true IdDict correctly implements DictInterface: true Dict correctly implements DictInterface: true Base.EnvDict correctly implements DictInterface: true GenericDict correctly implements DictInterface: true SubString correctly implements StringInterface: true SubstitutionString correctly implements StringInterface: true GenericString correctly implements StringInterface: true String correctly implements StringInterface: true LazyString correctly implements StringInterface: true Testing SetInterface is implemented for BitSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for Set Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for IdSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing IterationInterface is implemented for Number Mandatory components isempty: test iterator is not empty [true, true, true, true, true] iterate: (`iterate` does not return `nothing` [true, true, true, true, true], `iterate` returns a `Tuple` [true, true, true, true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true, true, true, true]) isiterable: [true, true, true, true, true] eltype: values of `x` are `<: eltype(x)` [true, true, true, true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true, true, true, true] Testing SetInterface is implemented for Base.KeySet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing IterationInterface is implemented for Array Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Pair Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Set Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Dict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Base.ImmutableDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for NamedTuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for UnitRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Base.Generator Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] Testing IterationInterface is implemented for BitSet Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for StepRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Tuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for String Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Base.EnvDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing ArrayInterface is implemented for PermutedDimsArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for BitArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true] Testing ArrayInterface is implemented for Array Mandatory components eltype: ([true, true], [true, true]) ndims: ([true, true], [true, true]) size: (size(A) returns a tuple of Integer [true, true], length of size(A) matches ndims(A) [true, true]) getindex: (Can index with begin/firstindex [true, true], Can index with end/lastindex [true, true], Can index with all indices in `eachindex(A)` [true, true], Can index with Int for multiple dimensions [true, true], Can index with Int for multiple dimensions and trailing ones [true, true], Can index with Int for multiple dimensions and trailing colons [true, true], Can index with CartesianIndex [true, true], Can index with CartesianIndex and trailing ones [true, true], Can index with CartesianIndices [true, true], Can index with CartesianIndices and trailing ones [true, true], Can index with CartesianIndices and trailing colons [true, true], Can index with UnitRange [true, true], Can index with UnitRange and trailing ones [true, true], Can index with UnitRange and trailing colons [true, true], Can index with StepRange [true, true], Can index with StepRange and trailing ones [true, true], Can index with StepRange and trailing colons [true, true], Can index with a Vector of Int [true, true], Can index with a Vector of Int32 [true, true], Can index with a Vector of Int with trailing ones [true, true], Can index with a Vector of Int with trailing colons [true, true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true, true] Optional components logical: (Can index with logical indices [true, true], Can index with logical indices and trailing ones [true, true], Can index with logical indices and trailing colons [true, true], Can index with multidimensional logical indices [true, true], Can index with multidimensional logical indices and trailing ones [true, true], Can index with multidimensional logical indices and trailing colons [true, true]) setindex!: (Bool[1, 1], Pair{String, Bool}["setindex! can write the first to the last element" => 1, "setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1, "setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1, "setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1, "setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true, true] similar_eltype: similar(A, T::Type) returns an object the same base type as `A` with eltype of `T` [true, true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true, true] Testing ArrayInterface is implemented for Base.OneTo Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for Base.CodeUnits Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for SubArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for Base.ReshapedArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for UnitRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for StepRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing DictInterface is implemented for Base.Pairs Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Base.ImmutableDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for IdDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Dict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Base.EnvDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing StringInterface is implemented for SubString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for SubstitutionString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for String Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for LazyString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Implementation summary: BitSet correctly implements SetInterface: true Set correctly implements SetInterface: true IdSet correctly implements SetInterface: true Number correctly implements IterationInterface: true Base.KeySet correctly implements SetInterface: true Array correctly implements IterationInterface: true Pair correctly implements IterationInterface: true Set correctly implements IterationInterface: true Dict correctly implements IterationInterface: true Base.ImmutableDict correctly implements IterationInterface: true NamedTuple correctly implements IterationInterface: true UnitRange correctly implements IterationInterface: true Base.Generator correctly implements IterationInterface: true BitSet correctly implements IterationInterface: true StepRange correctly implements IterationInterface: true Tuple correctly implements IterationInterface: true String correctly implements IterationInterface: true Base.EnvDict correctly implements IterationInterface: true PermutedDimsArray correctly implements ArrayInterface: true BitArray correctly implements ArrayInterface: true Array correctly implements ArrayInterface: true Base.OneTo correctly implements ArrayInterface: true Base.CodeUnits correctly implements ArrayInterface: true SubArray correctly implements ArrayInterface: true Base.ReshapedArray correctly implements ArrayInterface: true UnitRange correctly implements ArrayInterface: true StepRange correctly implements ArrayInterface: true Base.Pairs correctly implements DictInterface: true Base.ImmutableDict correctly implements DictInterface: true IdDict correctly implements DictInterface: true Dict correctly implements DictInterface: true Base.EnvDict correctly implements DictInterface: true SubString correctly implements StringInterface: true SubstitutionString correctly implements StringInterface: true String correctly implements StringInterface: true LazyString correctly implements StringInterface: true Testing SetInterface is implemented for GenericSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing DictInterface is implemented for GenericDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing StringInterface is implemented for GenericString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Implementation summary: GenericSet correctly implements SetInterface: true GenericDict correctly implements DictInterface: true GenericString correctly implements StringInterface: true Testing ArrayInterface is implemented for PermutedDimsArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for BitArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true] Testing ArrayInterface is implemented for Array Mandatory components eltype: ([true, true], [true, true]) ndims: ([true, true], [true, true]) size: (size(A) returns a tuple of Integer [true, true], length of size(A) matches ndims(A) [true, true]) getindex: (Can index with begin/firstindex [true, true], Can index with end/lastindex [true, true], Can index with all indices in `eachindex(A)` [true, true], Can index with Int for multiple dimensions [true, true], Can index with Int for multiple dimensions and trailing ones [true, true], Can index with Int for multiple dimensions and trailing colons [true, true], Can index with CartesianIndex [true, true], Can index with CartesianIndex and trailing ones [true, true], Can index with CartesianIndices [true, true], Can index with CartesianIndices and trailing ones [true, true], Can index with CartesianIndices and trailing colons [true, true], Can index with UnitRange [true, true], Can index with UnitRange and trailing ones [true, true], Can index with UnitRange and trailing colons [true, true], Can index with StepRange [true, true], Can index with StepRange and trailing ones [true, true], Can index with StepRange and trailing colons [true, true], Can index with a Vector of Int [true, true], Can index with a Vector of Int32 [true, true], Can index with a Vector of Int with trailing ones [true, true], Can index with a Vector of Int with trailing colons [true, true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true, true] Optional components logical: (Can index with logical indices [true, true], Can index with logical indices and trailing ones [true, true], Can index with logical indices and trailing colons [true, true], Can index with multidimensional logical indices [true, true], Can index with multidimensional logical indices and trailing ones [true, true], Can index with multidimensional logical indices and trailing colons [true, true]) setindex!: (Bool[1, 1], Pair{String, Bool}["setindex! can write the first to the last element" => 1, "setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1, "setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1, "setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1, "setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true, true] similar_eltype: similar(A, T::Type) returns an object the same base type as `A` with eltype of `T` [true, true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true, true] Testing ArrayInterface is implemented for Base.OneTo Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for Base.CodeUnits Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for SubArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for Base.ReshapedArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for UnitRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for StepRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Implementation summary: PermutedDimsArray correctly implements ArrayInterface: true BitArray correctly implements ArrayInterface: true Array correctly implements ArrayInterface: true Base.OneTo correctly implements ArrayInterface: true Base.CodeUnits correctly implements ArrayInterface: true SubArray correctly implements ArrayInterface: true Base.ReshapedArray correctly implements ArrayInterface: true UnitRange correctly implements ArrayInterface: true StepRange correctly implements ArrayInterface: true Testing DictInterface is implemented for Base.Pairs Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Base.ImmutableDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Dict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for IdDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Base.EnvDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Implementation summary: Base.Pairs correctly implements DictInterface: true Base.ImmutableDict correctly implements DictInterface: true Dict correctly implements DictInterface: true IdDict correctly implements DictInterface: true Base.EnvDict correctly implements DictInterface: true Testing IterationInterface is implemented for Number Mandatory components isempty: test iterator is not empty [true, true, true, true, true] iterate: (`iterate` does not return `nothing` [true, true, true, true, true], `iterate` returns a `Tuple` [true, true, true, true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true, true, true, true]) isiterable: [true, true, true, true, true] eltype: values of `x` are `<: eltype(x)` [true, true, true, true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true, true, true, true] Testing IterationInterface is implemented for Pair Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Array Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Set Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Dict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Base.ImmutableDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for NamedTuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for UnitRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Base.Generator Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] Testing IterationInterface is implemented for BitSet Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for StepRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Tuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Base.EnvDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for String Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Implementation summary: Number correctly implements IterationInterface: true Pair correctly implements IterationInterface: true Array correctly implements IterationInterface: true Set correctly implements IterationInterface: true Dict correctly implements IterationInterface: true Base.ImmutableDict correctly implements IterationInterface: true NamedTuple correctly implements IterationInterface: true UnitRange correctly implements IterationInterface: true Base.Generator correctly implements IterationInterface: true BitSet correctly implements IterationInterface: true StepRange correctly implements IterationInterface: true Tuple correctly implements IterationInterface: true Base.EnvDict correctly implements IterationInterface: true String correctly implements IterationInterface: true Testing SetInterface is implemented for BitSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for Set Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for IdSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing SetInterface is implemented for Base.KeySet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Implementation summary: BitSet correctly implements SetInterface: true Set correctly implements SetInterface: true IdSet correctly implements SetInterface: true Base.KeySet correctly implements SetInterface: true Testing StringInterface is implemented for SubString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for SubstitutionString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for String Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for LazyString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Implementation summary: SubString correctly implements StringInterface: true SubstitutionString correctly implements StringInterface: true String correctly implements StringInterface: true LazyString correctly implements StringInterface: true Testing ArrayInterface is implemented for PermutedDimsArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for BitArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true] Testing ArrayInterface is implemented for Array Mandatory components eltype: ([true, true], [true, true]) ndims: ([true, true], [true, true]) size: (size(A) returns a tuple of Integer [true, true], length of size(A) matches ndims(A) [true, true]) getindex: (Can index with begin/firstindex [true, true], Can index with end/lastindex [true, true], Can index with all indices in `eachindex(A)` [true, true], Can index with Int for multiple dimensions [true, true], Can index with Int for multiple dimensions and trailing ones [true, true], Can index with Int for multiple dimensions and trailing colons [true, true], Can index with CartesianIndex [true, true], Can index with CartesianIndex and trailing ones [true, true], Can index with CartesianIndices [true, true], Can index with CartesianIndices and trailing ones [true, true], Can index with CartesianIndices and trailing colons [true, true], Can index with UnitRange [true, true], Can index with UnitRange and trailing ones [true, true], Can index with UnitRange and trailing colons [true, true], Can index with StepRange [true, true], Can index with StepRange and trailing ones [true, true], Can index with StepRange and trailing colons [true, true], Can index with a Vector of Int [true, true], Can index with a Vector of Int32 [true, true], Can index with a Vector of Int with trailing ones [true, true], Can index with a Vector of Int with trailing colons [true, true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true, true] Optional components logical: (Can index with logical indices [true, true], Can index with logical indices and trailing ones [true, true], Can index with logical indices and trailing colons [true, true], Can index with multidimensional logical indices [true, true], Can index with multidimensional logical indices and trailing ones [true, true], Can index with multidimensional logical indices and trailing colons [true, true]) setindex!: (Bool[1, 1], Pair{String, Bool}["setindex! can write the first to the last element" => 1, "setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1, "setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1, "setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1, "setindex! can write to all indices in CartesianIndices(A)" => 1]) similar_type: `similar(A)` returns an object the same type and size as `A` [true, true] similar_eltype: similar(A, T::Type) returns an object the same base type as `A` with eltype of `T` [true, true] similar_size: similar(A, s::NTuple{Int}) returns an object the same type as `A` with size `s` [true, true] Testing ArrayInterface is implemented for Base.OneTo Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for Base.CodeUnits Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for SubArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for Base.ReshapedArray Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) setindex!: (Bool[1], Pair{String, Bool}["setindex! can write the first to the last element" => 1], Pair{String, Bool}["setindex! can write the first to the last element using multidimensional indices" => 1], Pair{String, Bool}["setindex! can write to all indices in eachindex(A)" => 1], Pair{String, Bool}["setindex! can write to all indices in CartesianIndices(A)" => 1]) Testing ArrayInterface is implemented for UnitRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Testing ArrayInterface is implemented for StepRange Mandatory components eltype: ([true], [true]) ndims: ([true], [true]) size: (size(A) returns a tuple of Integer [true], length of size(A) matches ndims(A) [true]) getindex: (Can index with begin/firstindex [true], Can index with end/lastindex [true], Can index with all indices in `eachindex(A)` [true], Can index with Int for multiple dimensions [true], Can index with Int for multiple dimensions and trailing ones [true], Can index with Int for multiple dimensions and trailing colons [true], Can index with CartesianIndex [true], Can index with CartesianIndex and trailing ones [true], Can index with CartesianIndices [true], Can index with CartesianIndices and trailing ones [true], Can index with CartesianIndices and trailing colons [true], Can index with UnitRange [true], Can index with UnitRange and trailing ones [true], Can index with UnitRange and trailing colons [true], Can index with StepRange [true], Can index with StepRange and trailing ones [true], Can index with StepRange and trailing colons [true], Can index with a Vector of Int [true], Can index with a Vector of Int32 [true], Can index with a Vector of Int with trailing ones [true], Can index with a Vector of Int with trailing colons [true]) indexstyle: IndexStyle returns IndexCartesian or IndexLinear [true] Optional components logical: (Can index with logical indices [true], Can index with logical indices and trailing ones [true], Can index with logical indices and trailing colons [true], Can index with multidimensional logical indices [true], Can index with multidimensional logical indices and trailing ones [true], Can index with multidimensional logical indices and trailing colons [true]) Implementation summary: PermutedDimsArray correctly implements ArrayInterface: true BitArray correctly implements ArrayInterface: true Array correctly implements ArrayInterface: true Base.OneTo correctly implements ArrayInterface: true Base.CodeUnits correctly implements ArrayInterface: true SubArray correctly implements ArrayInterface: true Base.ReshapedArray correctly implements ArrayInterface: true UnitRange correctly implements ArrayInterface: true StepRange correctly implements ArrayInterface: true Testing DictInterface is implemented for Base.Pairs Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Base.ImmutableDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for Dict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for IdDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Optional components setindex!: (test object `d` does not yet have test key `k` [true], can set key `k` to value `v` [true]) get!: (test object `d` does not yet have test key `k` [true], can set and get key `k` to value `v` with using get! [true]) delete!: can delete existing keys from the object [true] empty!: can empty the dictionary [true] Testing DictInterface is implemented for Base.EnvDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Testing DictInterface is implemented for GenericDict Mandatory components iterate: AbstractDict follows the IterationInterface [true] length: length is defined [true] eltype: (eltype is a Pair [true], the first value isa eltype [true]) keytype: keytype is the same as the first type in eltype parameters [true] valtype: valtype is the same as the second type in eltype paremeters [true] keys: keys are all of type keytype [true] values: values are all of type valtype [true] getindex: (getindex of the first key is the first object in `values` [true], getindex of all keys match values [true]) Implementation summary: Base.Pairs correctly implements DictInterface: true Base.ImmutableDict correctly implements DictInterface: true Dict correctly implements DictInterface: true IdDict correctly implements DictInterface: true Base.EnvDict correctly implements DictInterface: true GenericDict correctly implements DictInterface: true Testing IterationInterface is implemented for Number Mandatory components isempty: test iterator is not empty [true, true, true, true, true] iterate: (`iterate` does not return `nothing` [true, true, true, true, true], `iterate` returns a `Tuple` [true, true, true, true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true, true, true, true]) isiterable: [true, true, true, true, true] eltype: values of `x` are `<: eltype(x)` [true, true, true, true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true, true, true, true] Testing IterationInterface is implemented for Pair Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Array Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Set Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Dict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for Base.ImmutableDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for NamedTuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for UnitRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Base.Generator Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] Testing IterationInterface is implemented for BitSet Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for StepRange Mandatory components isempty: test iterator is not empty [true, true] iterate: (`iterate` does not return `nothing` [true, true], `iterate` returns a `Tuple` [true, true], second `iterate` returns a `Tuple` or `Nothing` [true, true]) isiterable: [true, true] eltype: values of `x` are `<: eltype(x)` [true, true] size: [(`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true), (`length(x)` returns an `Int` true, `size(x)` returns a `Tuple` of `Integer` true, `size(x)` matches the type parameter of `HasShape` true, `length(x)` is the product of size(x) true)] in: `in` returns true for all values in x [true, true] Optional components reverse: [true, true] indexing: (can call firstindex [true, true], can call lastindex [true, true], can call getindex [true, true], getindex matches iteration order [true, true]) Testing IterationInterface is implemented for Tuple Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Testing IterationInterface is implemented for Base.EnvDict Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Testing IterationInterface is implemented for String Mandatory components isempty: test iterator is not empty [true] iterate: (`iterate` does not return `nothing` [true], `iterate` returns a `Tuple` [true], second `iterate` returns a `Tuple` or `Nothing` [true]) isiterable: [true] eltype: values of `x` are `<: eltype(x)` [true] size: `length(x)` returns an `Integer` [true] in: `in` returns true for all values in x [true] Optional components reverse: [true] indexing: (can call firstindex [true], can call lastindex [true], can call getindex [true], getindex matches iteration order [true]) Implementation summary: Number correctly implements IterationInterface: true Pair correctly implements IterationInterface: true Array correctly implements IterationInterface: true Set correctly implements IterationInterface: true Dict correctly implements IterationInterface: true Base.ImmutableDict correctly implements IterationInterface: true NamedTuple correctly implements IterationInterface: true UnitRange correctly implements IterationInterface: true Base.Generator correctly implements IterationInterface: true BitSet correctly implements IterationInterface: true StepRange correctly implements IterationInterface: true Tuple correctly implements IterationInterface: true Base.EnvDict correctly implements IterationInterface: true String correctly implements IterationInterface: true Testing SetInterface is implemented for BitSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for GenericSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing SetInterface is implemented for Set Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components copy: creates an identical object with the same values, that is not the same object [true] empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] setdiff: (setdiff with itself is an empty set of the same type [true], setdiff with an empty set is equal to itself [true]) intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) empty!: empty! removes all elements from the set [true] delete!: delete! removes element valued x of the set [true] push!: push! adds an element to the set [true] copymutable: creates an identical mutable object with the same values, that is not the same object [true] sizehint!: can set a size hint [true] Testing SetInterface is implemented for IdSet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Testing SetInterface is implemented for Base.KeySet Mandatory components isempty: defines `isempty` and testdata is not empty [true] eltype: elements eltype of set `s` are subtypes of `eltype(s)` [true] length: set defines length and test object has length larger than zero [true] iteration: follows the IterationInterface [true] Optional components empty: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) emptymutable: (returns an empty set able to hold elements of type U [true], returns an empty set able to hold elements of arbitrary types [true]) hasfastin: `hasfastin` returns a `Bool` [true] intersect: (`intersect` of set with itself is itself [true], `intersect` of set with an empty set is an empty set [true]) union: (union of a set with itself equals itself [true], union of a set an empty set equals itself [true]) sizehint!: can set a size hint [true] Implementation summary: BitSet correctly implements SetInterface: true GenericSet correctly implements SetInterface: true Set correctly implements SetInterface: true IdSet correctly implements SetInterface: true Base.KeySet correctly implements SetInterface: true Testing StringInterface is implemented for SubString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for GenericString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Testing StringInterface is implemented for SubstitutionString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for String Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Testing StringInterface is implemented for LazyString Mandatory components ncodeunits: ncodeunit returns an Int [true] iterate: AbstractString follows the IterationInterface [true] codeunit: the first codeunit is a UInt8/16/32 [true] isvalid: isvalid returns a Bool [true] eltype: eltype returns a type <: AbatractChar [true] Optional components length: length return an Int [true] Implementation summary: SubString correctly implements StringInterface: true GenericString correctly implements StringInterface: true SubstitutionString correctly implements StringInterface: true String correctly implements StringInterface: true LazyString correctly implements StringInterface: true Testing ArrayInterface is implemented for Base.LogicalIndex Testing BaseInterfaces tests passed Testing completed after 221.72s PkgEval succeeded after 251.81s