Port TokenTest to Scalatest

Author: dwins

geocss/src/test/scala/TokenTest.scala

@@ -1,53 +1,55 @@
 package org.geoscript.geocss
 
-import org.specs2._
 import org.opengis.filter.Filter.{ INCLUDE, EXCLUDE }
 import org.opengis.{ filter => ogc }
+import org.scalatest._, matchers._
 
 /**
  * Tests for token methods
  */
-class TokenTest extends Specification with matcher.DataTables { 
+class TokenTest extends FunSuite with ShouldMatchers { 
   val filterFactory =
     org.geotools.factory.CommonFactoryFinder.getFilterFactory2(null)
   import filterFactory._
 
-  val expr = 
-    (org.geotools.filter.text.ecql.ECQL.toFilter(_: String)) andThen
-    (Selector.asSelector)
+  val expr = (x: String) => 
+    Selector.asSelector(org.geotools.filter.text.ecql.ECQL.toFilter(x))
   val expr1 = expr("a>b")
   val expr2 = expr("c<d")
 
-  def is = 
-    "'And' Selectors should do some basic simplification" ^ 
-       "empty And goes to Include" ! {
-         And(Nil).filterOpt must beSome(INCLUDE)
-       } ^ 
-       "single-element And goes to simple filter" ! {
-         And(List(expr1)).filterOpt must_== expr1.filterOpt
-       } ^
-       "'and' filter is correctly generated for larger And's" ! {
-         And(List(expr1, expr2)).filterOpt must_== 
-           (for { f <- expr1.filterOpt; g <- expr2.filterOpt }
-             yield and(f, g))
-       } ^ end ^
-    "'Not' selectors produce negated Filters" ! {
-      "selector"       | "filter"      |
-      Not(Accept)      ! Some(EXCLUDE) |
-      Not(Not(Accept)) ! Some(INCLUDE) |
-      Accept           ! Some(INCLUDE) |> {
-        (sel, filt) => sel.filterOpt must_== filt
-      }
-    } ^ end ^
-    "Spot checks on miscellaneous filter combos" ! {
-      "selector"                      | "criterion"                           |
-      expr1                           ! beAnInstanceOf[ogc.PropertyIsGreaterThan] |
-      Not(expr1)                      ! beAnInstanceOf[ogc.Not]                   |
-      Or(List(expr1))                 ! beAnInstanceOf[ogc.PropertyIsGreaterThan] |
-      And(List(expr1))                ! beAnInstanceOf[ogc.PropertyIsGreaterThan] |
-      Not(And(List(expr1)))           ! beAnInstanceOf[ogc.Not] |
-      Or(List(And(List(expr1))))      ! beAnInstanceOf[ogc.PropertyIsGreaterThan] |
-      Or(List(And(List(Not(expr1))))) ! beAnInstanceOf[ogc.Not] |>
-      { (sel, pass) => sel.filterOpt must beSome.which(_ must pass) }
+  test("empty And goes to Include") {
+    And(Nil).filterOpt should be(Some(INCLUDE))
+  }
+
+  test("single-element And goes to simple filter") {
+    And(List(expr1)).filterOpt should equal(expr1.filterOpt)
+  }
+
+  test("'and' filter is correctly generated for larger And's") {
+    val expected = 
+      for { 
+        f <- expr1.filterOpt
+        g <- expr2.filterOpt
+      } yield and(f, g)
+
+    expect(expected) {
+      And(List(expr1, expr2)).filterOpt
     }
+  }
+
+  test("'Not' selectors produce negated Filters") {
+    Not(Accept).filterOpt should equal(Some(EXCLUDE))
+    Not(Not(Accept)).filterOpt should equal(Some(INCLUDE))
+    Accept.filterOpt should equal(Some(INCLUDE))
+  }
+
+  test("Spot checks on miscellaneous filter combos") {
+    assert(expr1.filterOpt exists(_.isInstanceOf[ogc.PropertyIsGreaterThan]))
+    assert(Not(expr1).filterOpt exists(_.isInstanceOf[ogc.Not]))
+    assert(Or(List(expr1)).filterOpt exists(_.isInstanceOf[ogc.PropertyIsGreaterThan]))
+    assert(And(List(expr1)).filterOpt exists(_.isInstanceOf[ogc.PropertyIsGreaterThan]))
+    assert(Not(And(List(expr1))).filterOpt exists(_.isInstanceOf[ogc.Not]))
+    assert(Or(List(And(List(expr1)))).filterOpt exists(_.isInstanceOf[ogc.PropertyIsGreaterThan]))
+    assert(Or(List(And(List(Not(expr1))))).filterOpt exists(_.isInstanceOf[ogc.Not]))
+  }
 }