group tests with @testset

Author: alyst

test/cat.jl

@@ -1,19 +1,15 @@
-module TestCat
-    using Base.Test
-    using DataFrames
-
-    #
-    # hcat
-    #
-
+@testset "concatenation" begin
     nvint = NullableArray(Nullable{Int}[1, 2, Nullable(), 4])
     nvstr = NullableArray(Nullable{String}["one", "two", Nullable(), "four"])
 
+    null_df = DataFrame(Int, 0, 0)
+    df = DataFrame(Int, 4, 3)
     df2 = DataFrame(Any[nvint, nvstr])
     df3 = DataFrame(Any[nvint])
     df4 = convert(DataFrame, [1:4 1:4])
     df5 = DataFrame(Any[NullableArray([1,2,3,4]), nvstr])
 
+@testset "hcat()" begin
     dfh = hcat(df3, df4)
     @test size(dfh, 2) == 3
     @test names(dfh) == [:x1, :x1_1, :x2]
@@ -27,14 +23,9 @@ module TestCat
     @test isequal(dfh3, DataFrames.hcat!(DataFrame(), df3, df4, df5))
 
     @test isequal(df2, DataFrames.hcat!(df2))
+end
 
-    #
-    # vcat
-    #
-
-    null_df = DataFrame(Int, 0, 0)
-    df = DataFrame(Int, 4, 3)
-
+@testset "broadcasting" begin
     # Assignment of rows
     df[1, :] = df[1, :]
     df[1:2, :] = df[1:2, :]
@@ -71,7 +62,9 @@ module TestCat
     # vector broadcasting assignment of subframes
     df[1:2, 1:2] = [3,2]
     df[[true,false,false,true], 2:3] = [2,3]
+end
 
+@testset "vcat()" begin
     vcat([])
     vcat(null_df)
     vcat(null_df, null_df)
@@ -149,3 +142,5 @@ module TestCat
     # vcat should be able to concatenate different implementations of AbstractDataFrame (PR #944)
     @test isequal(vcat(sub(DataFrame(A=1:3),2),DataFrame(A=4:5)), DataFrame(A=[2,4,5]))
 end
+
+end

test/contrasts.jl

@@ -1,13 +1,10 @@
-module TestContrasts
-
-using Base.Test
-using DataFrames
-
+@testset "Contrasts" begin
 
 d = DataFrame(x = CategoricalVector([:a, :b, :c, :a, :a, :b]))
 
 mf = ModelFrame(Formula(nothing, :x), d)
 
+@testset "Dummy" begin
 # Dummy coded contrasts by default:
 @test ModelMatrix(mf).m == [1  0  0
                             1  1  0
@@ -20,7 +17,9 @@ mf = ModelFrame(Formula(nothing, :x), d)
 mmm = ModelMatrix(mf).m
 setcontrasts!(mf, x = DummyCoding())
 @test ModelMatrix(mf).m == mmm
+end
 
+@testset "Effects" begin
 setcontrasts!(mf, x = EffectsCoding())
 @test ModelMatrix(mf).m == [1 -1 -1
                             1  1  0
@@ -50,7 +49,6 @@ setcontrasts!(mf, x = EffectsCoding(levels = [:c, :b, :a]))
                             1  1  0]
 @test coefnames(mf) == ["(Intercept)"; "x: b"; "x: a"]
 
-
 # change levels and base level of contrast
 setcontrasts!(mf, x = EffectsCoding(levels = [:c, :b, :a], base = :a))
 @test ModelMatrix(mf).m == [1 -1 -1
@@ -61,6 +59,7 @@ setcontrasts!(mf, x = EffectsCoding(levels = [:c, :b, :a], base = :a))
                             1  0  1]
 @test coefnames(mf) == ["(Intercept)"; "x: c"; "x: b"]
 
+@testset "Helmert" begin
 # Helmert coded contrasts
 setcontrasts!(mf, x = HelmertCoding())
 @test ModelMatrix(mf).m == [1 -1 -1
@@ -70,7 +69,9 @@ setcontrasts!(mf, x = HelmertCoding())
                             1 -1 -1
                             1  1 -1]
 @test coefnames(mf) == ["(Intercept)"; "x: b"; "x: c"]
+end
 
+@testset "Incorrect input data" begin
 # Mismatching types of data and contrasts levels throws an error:
 @test_throws ArgumentError setcontrasts!(mf, x = EffectsCoding(levels = ["a", "b", "c"]))
 
@@ -91,6 +92,7 @@ mf_missing = ModelFrame(Formula(nothing, :x), d, contrasts = Dict(:x => EffectsC
 @test_throws ArgumentError setcontrasts!(mf, x = EffectsCoding(levels = [:a, :b, :c, :d]))
 # Asking for base level that's not found in data
 @test_throws ArgumentError setcontrasts!(mf, x = EffectsCoding(base = :e))
+end
 
 # Manually specified contrasts
 contrasts = [0  1
@@ -110,5 +112,6 @@ setcontrasts!(mf, x = ContrastsCoding(contrasts))
 
 # contrasts types must be instaniated
 @test_throws ArgumentError setcontrasts!(mf, x = DummyCoding)
+end
 
 end

test/data.jl

@@ -1,36 +1,32 @@
-module TestData
-    importall Base # so that we get warnings for conflicts
-    using Base.Test
-    using DataFrames
-    using Compat.String
-
-    #test_group("NullableArray creation")
-    nvint = NullableArray(Nullable{Int}[1, 2, Nullable(), 4])
-    nvint2 = NullableArray(5:8)
-    nvint3 = NullableArray(5:8)
-    nvflt = NullableArray(Nullable{Float64}[1.0, 2.0, Nullable(), 4.0])
-    nvstr = NullableArray(Nullable{String}["one", "two", Nullable(), "four"])
-    dvdict = NullableArray(Dict, 4)    # for issue #199
-
-    #test_group("constructors")
-    df1 = DataFrame(Any[nvint, nvstr], [:Ints, :Strs])
-    df2 = DataFrame(Any[nvint, nvstr])
-    df3 = DataFrame(Any[nvint])
-    df4 = convert(DataFrame, [1:4 1:4])
-    df5 = DataFrame(Any[NullableArray([1,2,3,4]), nvstr])
-    df6 = DataFrame(Any[nvint, nvint, nvstr], [:A, :B, :C])
-    df7 = DataFrame(x = nvint, y = nvstr)
-    @test size(df7) == (4, 2)
-    @test isequal(df7[:x], nvint)
-
-    #test_group("description functions")
-    @test size(df6, 1) == 4
-    @test size(df6, 2) == 3
-    @test names(df6) == [:A, :B, :C]
-    @test names(df2) == [:x1, :x2]
-    @test names(df7) == [:x, :y]
-
-    #test_group("ref")
+@testset "Assorted DataFrame tests" begin # TODO redistribute/remove?
+
+# NullableArray creation
+nvint = NullableArray(Nullable{Int}[1, 2, Nullable(), 4])
+nvint2 = NullableArray(5:8)
+nvint3 = NullableArray(5:8)
+nvflt = NullableArray(Nullable{Float64}[1.0, 2.0, Nullable(), 4.0])
+nvstr = NullableArray(Nullable{String}["one", "two", Nullable(), "four"])
+dvdict = NullableArray(Dict, 4)    # for issue #199
+
+# constructors
+df1 = DataFrame(Any[nvint, nvstr], [:Ints, :Strs])
+df2 = DataFrame(Any[nvint, nvstr])
+df3 = DataFrame(Any[nvint])
+df4 = convert(DataFrame, [1:4 1:4])
+df5 = DataFrame(Any[NullableArray([1,2,3,4]), nvstr])
+df6 = DataFrame(Any[nvint, nvint, nvstr], [:A, :B, :C])
+df7 = DataFrame(x = nvint, y = nvstr)
+@test size(df7) == (4, 2)
+@test isequal(df7[:x], nvint)
+
+# description functions
+@test size(df6, 1) == 4
+@test size(df6, 2) == 3
+@test names(df6) == [:A, :B, :C]
+@test names(df2) == [:x1, :x2]
+@test names(df7) == [:x, :y]
+
+@testset "ref" begin
     @test isequal(df6[2, 3], Nullable("two"))
     @test isnull(df6[3, 3])
     @test isequal(df6[2, :C], Nullable("two"))
@@ -41,8 +37,9 @@ module TestData
     @test size(df6[1:2, 1:2]) == (2, 2)
     @test size(head(df6,2)) == (2, 3)
     # lots more to do
+end
 
-    #test_group("assign")
+@testset "assign" begin
     df6[3] = NullableArray(["un", "deux", "troix", "quatre"])
     @test isequal(df6[1, 3], Nullable("un"))
     df6[:B] = [4, 3, 2, 1]
@@ -52,12 +49,13 @@ module TestData
     delete!(df6, :D)
     @test names(df6) == [:A, :B, :C]
     @test size(df6, 2) == 3
+end
 
-    #test_group("null handling")
+@testset "null handling" begin
     @test nrow(df5[complete_cases(df5), :]) == 3
+end
 
-    #test_context("SubDataFrames")
-
+@testset "SubDataFrame" begin
     #test_group("constructors")
     # single index is rows
     sdf6a = sub(df6, 1)
@@ -69,11 +67,12 @@ module TestData
 
     #test_group("ref")
     @test isequal(sdf6a[1,2], Nullable(4))
+end
 
     #test_context("Within")
     #test_group("Associative")
 
-    #test_group("DataFrame")
+@testset "Grouping" begin
     srand(1)
     N = 20
     #Cast to Int64 as rand() behavior differs between Int32/64
@@ -83,7 +82,6 @@ module TestData
     d4 = NullableArray(randn(N))
     df7 = DataFrame(Any[d1, d2, d3], [:d1, :d2, :d3])
 
-    #test_group("groupby")
     gd = groupby(df7, :d1)
     @test isa(gd, GroupedDataFrame)
     @test length(gd) == 2
@@ -133,8 +131,9 @@ module TestData
     @test ggd[1][2, :d4] == "c"
     @test ggd[2][1, :d3] == "a"
     @test ggd[2][1, :d4] == "d"
+end
 
-    #test_group("reshape")
+@testset "reshape" begin
     d1 = DataFrame(a = repeat([1:3;], inner = [4]),
                    b = repeat([1:4;], inner = [3]),
                    c = randn(12),
@@ -175,9 +174,9 @@ module TestData
     @test isequal(d1us[:a], d1[:a])
     @test isequal(d1us2[:d], d1[:d])
     @test isequal(d1us2[:3], d1[:d])
+end
 
-
-
+@testset "join" begin
     d2 = DataFrame(id1 = [:a, :a, :a, :b],
                    id2 = [:A, :B, :B, :B],
                    id3 = [:t, :f, :t, :f],
@@ -225,22 +224,23 @@ module TestData
     m4 = join(df1, df2, on = :a, kind = :outer)
     @test isequal(m4[:a], NullableArray([1, 2, 3, 4]))
 
-    # test with nulls (issue #185)
-    df1 = DataFrame()
-    df1[:A] = NullableArray(Nullable{Compat.ASCIIString}["a", "b", "a", Nullable()])
-    df1[:B] = NullableArray([1, 2, 1, 3])
+    @testset "test with nulls (issue #185)" begin
+        df1 = DataFrame()
+        df1[:A] = NullableArray(Nullable{Compat.ASCIIString}["a", "b", "a", Nullable()])
+        df1[:B] = NullableArray([1, 2, 1, 3])
 
-    df2 = DataFrame()
-    df2[:A] = NullableArray(Nullable{Compat.ASCIIString}["a", Nullable(), "c"])
-    df2[:C] = NullableArray([1, 2, 4])
+        df2 = DataFrame()
+        df2[:A] = NullableArray(Nullable{Compat.ASCIIString}["a", Nullable(), "c"])
+        df2[:C] = NullableArray([1, 2, 4])
 
-    m1 = join(df1, df2, on = :A)
-    @test size(m1) == (3,3)
-    @test isequal(m1[:A], NullableArray(Nullable{Compat.ASCIIString}["a","a",Nullable()]))
+        m1 = join(df1, df2, on = :A)
+        @test size(m1) == (3,3)
+        @test isequal(m1[:A], NullableArray(Nullable{Compat.ASCIIString}["a","a",Nullable()]))
 
-    m2 = join(df1, df2, on = :A, kind = :outer)
-    @test size(m2) == (5,3)
-    @test isequal(m2[:A], NullableArray(Nullable{Compat.ASCIIString}["a","b","a",Nullable(),"c"]))
+        m2 = join(df1, df2, on = :A, kind = :outer)
+        @test size(m2) == (5,3)
+        @test isequal(m2[:A], NullableArray(Nullable{Compat.ASCIIString}["a","b","a",Nullable(),"c"]))
+    end
 
     srand(1)
     df1 = DataFrame(
@@ -265,7 +265,9 @@ module TestData
     #               NullableArray(Nullable{String}["x", "x", "y", "y",
     #                                              "x", "x", "x", "x", "x", "y",
     #                                              Nullable(), "y"])
+end
 
+@testset "unique" begin
     srand(1)
     function spltdf(d)
         d[:x1] = map(x -> get(x)[1], d[:a])
@@ -313,3 +315,5 @@ module TestData
     unique!(df, [1, 3])
     @test isequal(df, df1)
 end
+
+end