Check uniqueness of column selection & Add more tests (#3)

Author: eliascarv

src/selectors.jl

@@ -5,6 +5,9 @@ struct IndexSelector <: ColumnSelector
     if isempty(inds)
       throw(ArgumentError("column selection cannot be empty"))
     end
+    if !allunique(inds)
+      throw(ArgumentError("column indices must be unique"))
+    end
     new(inds)
   end
 end
@@ -23,6 +26,9 @@ struct NameSelector <: ColumnSelector
     if isempty(names)
       throw(ArgumentError("column selection cannot be empty"))
     end
+    if !allunique(names)
+      throw(ArgumentError("column names must be unique"))
+    end
     new(names)
   end
 end

test/runtests.jl

@@ -5,71 +5,81 @@ using Test
   vecnames = [:a, :b, :c, :d, :e, :f]
   tupnames = (:a, :b, :c, :d, :e, :f)
 
-  # vector of integers
+  # index selector: vector of integers
   selector = CS.selector([1, 3, 5])
+  @test selector isa CS.IndexSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # tuple of integers
+  # index selector: tuple of integers
   selector = CS.selector((1, 3, 5))
+  @test selector isa CS.IndexSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # vector of symbols
+  # name selector: vector of symbols
   selector = CS.selector([:a, :c, :e])
+  @test selector isa CS.NameSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # tuple of symbols
+  # name selector: tuple of symbols
   selector = CS.selector((:a, :c, :e))
+  @test selector isa CS.NameSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # vector of strings
+  # name selector: vector of strings
   selector = CS.selector(["a", "c", "e"])
+  @test selector isa CS.NameSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # tuple of strings
+  # name selector: tuple of strings
   selector = CS.selector(("a", "c", "e"))
+  @test selector isa CS.NameSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # regex
+  # regex selector: regex
   selector = CS.selector(r"[ace]")
+  @test selector isa CS.RegexSelector
   snames = selector(vecnames)
   @test snames == [:a, :c, :e]
   snames = selector(tupnames)
   @test snames == [:a, :c, :e]
 
-  # colon
+  # all selector: colon
   selector = CS.selector(:)
+  @test selector isa CS.AllSelector
   snames = selector(vecnames)
   @test snames == [:a, :b, :c, :d, :e, :f]
   snames = selector(tupnames)
   @test snames == [:a, :b, :c, :d, :e, :f]
 
-  # nothing
+  # none selector: nothing
   selector = CS.selector(nothing)
+  @test selector isa CS.NoneSelector
   snames = selector(vecnames)
   @test snames == Symbol[]
   snames = selector(tupnames)
   @test snames == Symbol[]
 
-  # single integer
+  # single index selector: integer
   selector = CS.selector(1)
+  @test selector isa CS.SingleIndexSelector
   sname = CS.selectsingle(selector, vecnames)
   snames = CS.select(selector, vecnames)
   @test sname == :a
@@ -79,8 +89,9 @@ using Test
   @test sname == :a
   @test snames == [:a]
 
-  # single symbol
+  # single name selector: symbol
   selector = CS.selector(:b)
+  @test selector isa CS.SingleNameSelector
   sname = CS.selectsingle(selector, vecnames)
   snames = CS.select(selector, vecnames)
   @test sname == :b
@@ -90,8 +101,9 @@ using Test
   @test sname == :b
   @test snames == [:b]
 
-  # single string
+  # single name selector: string
   selector = CS.selector("c")
+  @test selector isa CS.SingleNameSelector
   sname = CS.selectsingle(selector, vecnames)
   snames = CS.select(selector, vecnames)
   @test sname == :c
@@ -101,13 +113,23 @@ using Test
   @test sname == :c
   @test snames == [:c]
 
+  # fallback: another selector
+  selector = CS.selector(CS.NoneSelector())
+  @test selector isa CS.NoneSelector
+
   # shows
   selector = CS.selector([1, 2, 3])
   @test sprint(show, selector) == "[1, 2, 3]"
+  selector = CS.selector((1, 2, 3))
+  @test sprint(show, selector) == "[1, 2, 3]"
+  selector = CS.selector([:a, :b, :c])
+  @test sprint(show, selector) == "[:a, :b, :c]"
   selector = CS.selector((:a, :b, :c))
   @test sprint(show, selector) == "[:a, :b, :c]"
   selector = CS.selector(["a", "b", "c"])
   @test sprint(show, selector) == "[:a, :b, :c]"
+  selector = CS.selector(("a", "b", "c"))
+  @test sprint(show, selector) == "[:a, :b, :c]"
   selector = CS.selector(r"[abc]")
   @test sprint(show, selector) == "r\"[abc]\""
   selector = CS.selector(:)
@@ -129,6 +151,14 @@ using Test
   @test_throws ArgumentError CS.selector(Int[])
   @test_throws ArgumentError CS.selector(Symbol[])
   @test_throws ArgumentError CS.selector(String[])
+  # column indices must be unique
+  @test_throws ArgumentError CS.selector([1, 2, 2])
+  @test_throws ArgumentError CS.selector((1, 2, 2))
+  # column names must be unique
+  @test_throws ArgumentError CS.selector([:a, :b, :b])
+  @test_throws ArgumentError CS.selector((:a, :b, :b))
+  @test_throws ArgumentError CS.selector(["a", "b", "b"])
+  @test_throws ArgumentError CS.selector(("a", "b", "b"))
   # regex doesn't match any names in input table
   selector = CS.selector(r"x")
   @test_throws AssertionError CS.select(selector, vecnames)