Move from FactCheck to Base.Test (#44)

* Fix deprecations

* No CI on julia v0.5

* Move from FactCheck to Base.Test

* Comment out failing test until we address #21

Author: visr

.travis.yml

@@ -3,7 +3,6 @@ os:
     - osx
     - linux
 julia:
-    - 0.5
     - 0.6
     - nightly
 matrix:

appveyor.yml

@@ -1,7 +1,5 @@
 environment:
   matrix:
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.5/julia-0.5-latest-win32.exe"
-  - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.5/julia-0.5-latest-win64.exe"
   - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x86/0.6/julia-0.6-latest-win32.exe"
   - JULIA_URL: "https://julialang-s3.julialang.org/bin/winnt/x64/0.6/julia-0.6-latest-win64.exe"
   - JULIA_URL: "https://julialangnightlies-s3.julialang.org/bin/winnt/x86/julia-latest-win32.exe"

src/LibGEOS.jl

@@ -26,7 +26,7 @@ module LibGEOS
 
     include("geos_c.jl")
 
-    type GEOSError <: Exception
+    mutable struct GEOSError <: Exception
         msg::String
     end
     Base.showerror(io::IO, err::GEOSError) = print(io, "GEOSError\n\t$(err.msg)")
@@ -39,7 +39,7 @@ module LibGEOS
         end
     end
 
-    type GEOSconnection
+    mutable struct GEOSconnection
         status::Symbol
 
         function GEOSconnection()

src/geos_types.jl

@@ -1,4 +1,4 @@
-type Point <: GeoInterface.AbstractPoint
+mutable struct Point <: GeoInterface.AbstractPoint
     ptr::GEOSGeom
 
     function Point(ptr::GEOSGeom)
@@ -9,10 +9,10 @@ type Point <: GeoInterface.AbstractPoint
     Point(coords::Vector{Float64}) = Point(createPoint(coords))
     Point(x::Real, y::Real) = Point(createPoint(x,y))
     Point(x::Real, y::Real, z::Real) = Point(createPoint(x,y,z))
-    Point{T<:GeoInterface.AbstractPoint}(obj::T) = Point(GeoInterface.coordinates(obj))
+    Point(obj::T) where {T<:GeoInterface.AbstractPoint} = Point(GeoInterface.coordinates(obj))
 end
 
-type MultiPoint <: GeoInterface.AbstractMultiPoint
+mutable struct MultiPoint <: GeoInterface.AbstractMultiPoint
     ptr::GEOSGeom
 
     function MultiPoint(ptr::GEOSGeom)
@@ -21,10 +21,10 @@ type MultiPoint <: GeoInterface.AbstractMultiPoint
         multipoint
     end
     MultiPoint(multipoint::Vector{Vector{Float64}}) = MultiPoint(createCollection(GEOS_MULTIPOINT, GEOSGeom[createPoint(coords) for coords in multipoint]))
-    MultiPoint{T<:GeoInterface.AbstractMultiPoint}(obj::T) = MultiPoint(GeoInterface.coordinates(obj))
+    MultiPoint(obj::T) where {T<:GeoInterface.AbstractMultiPoint} = MultiPoint(GeoInterface.coordinates(obj))
 end
 
-type LineString <: GeoInterface.AbstractLineString
+mutable struct LineString <: GeoInterface.AbstractLineString
     ptr::GEOSGeom
 
     function LineString(ptr::GEOSGeom)
@@ -33,10 +33,10 @@ type LineString <: GeoInterface.AbstractLineString
         line
     end
     LineString(line::Vector{Vector{Float64}}) = LineString(createLineString(line))
-    LineString{T<:GeoInterface.AbstractLineString}(obj::T) = LineString(GeoInterface.coordinates(obj))
+    LineString(obj::T) where {T<:GeoInterface.AbstractLineString} = LineString(GeoInterface.coordinates(obj))
 end
 
-type MultiLineString <: GeoInterface.AbstractMultiLineString
+mutable struct MultiLineString <: GeoInterface.AbstractMultiLineString
     ptr::GEOSGeom
 
     function MultiLineString(ptr::GEOSGeom)
@@ -45,10 +45,10 @@ type MultiLineString <: GeoInterface.AbstractMultiLineString
         multiline
     end
     MultiLineString(multiline::Vector{Vector{Vector{Float64}}}) = MultiLineString(createCollection(GEOS_MULTILINESTRING, GEOSGeom[createLineString(coords) for coords in multiline]))
-    MultiLineString{T<:GeoInterface.AbstractMultiLineString}(obj::T) = MultiLineString(GeoInterface.coordinates(obj))
+    MultiLineString(obj::T) where {T<:GeoInterface.AbstractMultiLineString} = MultiLineString(GeoInterface.coordinates(obj))
 end
 
-type LinearRing <: GeoInterface.AbstractLineString
+mutable struct LinearRing <: GeoInterface.AbstractLineString
     ptr::GEOSGeom
 
     function LinearRing(ptr::GEOSGeom)
@@ -57,10 +57,10 @@ type LinearRing <: GeoInterface.AbstractLineString
         ring
     end
     LinearRing(ring::Vector{Vector{Float64}}) = LinearRing(createLinearRing(ring))
-    LinearRing{T<:GeoInterface.AbstractLineString}(obj::T) = LinearRing(GeoInterface.coordinates(obj))
+    LinearRing(obj::T) where {T<:GeoInterface.AbstractLineString} = LinearRing(GeoInterface.coordinates(obj))
 end
 
-type Polygon <: GeoInterface.AbstractPolygon
+mutable struct Polygon <: GeoInterface.AbstractPolygon
     ptr::GEOSGeom
 
     function Polygon(ptr::GEOSGeom)
@@ -75,10 +75,10 @@ type Polygon <: GeoInterface.AbstractPolygon
         finalizer(polygon, destroyGeom)
         polygon
     end
-    Polygon{T<:GeoInterface.AbstractPolygon}(obj::T) = Polygon(GeoInterface.coordinates(obj))
+    Polygon(obj::T) where {T<:GeoInterface.AbstractPolygon} = Polygon(GeoInterface.coordinates(obj))
 end
 
-type MultiPolygon <: GeoInterface.AbstractMultiPolygon
+mutable struct MultiPolygon <: GeoInterface.AbstractMultiPolygon
     ptr::GEOSGeom
 
     function MultiPolygon(ptr::GEOSGeom)
@@ -91,10 +91,10 @@ type MultiPolygon <: GeoInterface.AbstractMultiPolygon
                                       GEOSGeom[createPolygon(createLinearRing(coords[1]),
                                                              GEOSGeom[createLinearRing(c) for c in coords[2:end]])
                                                for coords in multipolygon]))
-    MultiPolygon{T<:GeoInterface.AbstractMultiPolygon}(obj::T) = MultiPolygon(GeoInterface.coordinates(obj))
+    MultiPolygon(obj::T) where {T<:GeoInterface.AbstractMultiPolygon} = MultiPolygon(GeoInterface.coordinates(obj))
 end
 
-type GeometryCollection <: GeoInterface.AbstractGeometryCollection
+mutable struct GeometryCollection <: GeoInterface.AbstractGeometryCollection
     ptr::GEOSGeom
 
     function GeometryCollection(ptr::GEOSGeom)

test/REQUIRE

@@ -1,10 +1,10 @@
 import GeoInterface
-using FactCheck, LibGEOS
+using Base.Test, LibGEOS
 
-include("test_geos_functions.jl")
-include("test_geos_operations.jl")
-include("test_geo_interface.jl")
-include("test_regressions.jl")
-include("test_invalid_geometry.jl")
-
-FactCheck.exitstatus()
+@testset "LibGEOS" begin
+    include("test_geos_functions.jl")
+    include("test_geos_operations.jl")
+    include("test_geo_interface.jl")
+    include("test_regressions.jl")
+    include("test_invalid_geometry.jl")
+end

test/runtests.jl

@@ -1,53 +1,53 @@
-facts("Geo interface") do
+@testset "Geo interface" begin
     pt = LibGEOS.Point(1.0,2.0)
-    @fact GeoInterface.coordinates(pt) --> roughly([1,2], 1e-5)
-    @fact GeoInterface.geotype(pt) --> :Point
+    @test GeoInterface.coordinates(pt) ≈ [1,2] atol=1e-5
+    @test GeoInterface.geotype(pt) == :Point
 
     pt = LibGEOS.Point(1, 2)
-    @fact GeoInterface.coordinates(pt) --> roughly([1,2], 1e-5)
-    @fact GeoInterface.geotype(pt) --> :Point
+    @test GeoInterface.coordinates(pt) ≈ [1,2] atol=1e-5
+    @test GeoInterface.geotype(pt) == :Point
 
 
     pt = LibGEOS.Point(LibGEOS.geomFromWKT("POINT EMPTY"))
-    @fact GeoInterface.coordinates(pt) --> roughly(Float64[], 1e-5)
-    @fact GeoInterface.geotype(pt) --> :Point
+    @test GeoInterface.coordinates(pt) ≈ Float64[] atol=1e-5
+    @test GeoInterface.geotype(pt) == :Point
 
     mpt = LibGEOS.MultiPoint(LibGEOS.geomFromWKT("MULTIPOINT(0 0, 10 0, 10 10, 11 10)"))
-    @fact GeoInterface.coordinates(mpt) --> Vector{Float64}[[0,0],[10,0],[10,10],[11,10]]
-    @fact GeoInterface.geotype(mpt) --> :MultiPoint
+    @test GeoInterface.coordinates(mpt) == Vector{Float64}[[0,0],[10,0],[10,10],[11,10]]
+    @test GeoInterface.geotype(mpt) == :MultiPoint
 
     coords = Vector{Float64}[[8,1],[9,1],[9,2],[8,2]]
     ls = LibGEOS.LineString(coords)
-    @fact GeoInterface.coordinates(ls) --> coords
-    @fact GeoInterface.geotype(ls) --> :LineString
+    @test GeoInterface.coordinates(ls) == coords
+    @test GeoInterface.geotype(ls) == :LineString
 
     ls = LibGEOS.LineString(LibGEOS.geomFromWKT("LINESTRING EMPTY"))
-    @fact GeoInterface.coordinates(ls) --> []
-    @fact GeoInterface.geotype(ls) --> :LineString
+    @test GeoInterface.coordinates(ls) == []
+    @test GeoInterface.geotype(ls) == :LineString
 
     mls = LibGEOS.MultiLineString(LibGEOS.geomFromWKT("MULTILINESTRING ((5 0, 10 0), (0 0, 5 0))"))
-    @fact GeoInterface.coordinates(mls) --> [[[5,0],[10,0]],[[0,0],[5,0]]]
-    @fact GeoInterface.geotype(mls) --> :MultiLineString
+    @test GeoInterface.coordinates(mls) == [[[5,0],[10,0]],[[0,0],[5,0]]]
+    @test GeoInterface.geotype(mls) == :MultiLineString
 
     coords = Vector{Float64}[[8,1],[9,1],[9,2],[8,2],[8,1]]
     lr = LibGEOS.LinearRing(coords)
-    @fact GeoInterface.coordinates(lr) --> coords
-    @fact GeoInterface.geotype(lr) --> :LineString
+    @test GeoInterface.coordinates(lr) == coords
+    @test GeoInterface.geotype(lr) == :LineString
 
     coords = Vector{Vector{Float64}}[Vector{Float64}[[0,0],[10,0],[10,10],[0,10],[0,0]],
                                      Vector{Float64}[[1,8],[2,8],[2,9],[1,9],[1,8]],
                                      Vector{Float64}[[8,1],[9,1],[9,2],[8,2],[8,1]]]
     polygon = LibGEOS.Polygon(coords)
-    @fact GeoInterface.coordinates(polygon) --> coords
-    @fact GeoInterface.geotype(polygon) --> :Polygon
+    @test GeoInterface.coordinates(polygon) == coords
+    @test GeoInterface.geotype(polygon) == :Polygon
 
     polygon = LibGEOS.Polygon(LibGEOS.geomFromWKT("POLYGON EMPTY"))
-    @fact GeoInterface.coordinates(polygon) --> [[]]
-    @fact GeoInterface.geotype(polygon) --> :Polygon
+    @test GeoInterface.coordinates(polygon) == [[]]
+    @test GeoInterface.geotype(polygon) == :Polygon
 
     multipolygon = LibGEOS.MultiPolygon(LibGEOS.geomFromWKT("MULTIPOLYGON(((0 0,0 10,10 10,10 0,0 0)))"))
-    @fact GeoInterface.coordinates(multipolygon) --> Vector{Vector{Vector{Float64}}}[Vector{Vector{Float64}}[Vector{Float64}[[0,0],[0,10],[10,10],[10,0],[0,0]]]]
-    @fact GeoInterface.geotype(multipolygon) --> :MultiPolygon
+    @test GeoInterface.coordinates(multipolygon) == Vector{Vector{Vector{Float64}}}[Vector{Vector{Float64}}[Vector{Float64}[[0,0],[0,10],[10,10],[10,0],[0,0]]]]
+    @test GeoInterface.geotype(multipolygon) == :MultiPolygon
 
     geomcollection = LibGEOS.GeometryCollection(LibGEOS.geomFromWKT("GEOMETRYCOLLECTION (POLYGON ((8 2, 10 10, 8.5 1, 8 2)), POLYGON ((7 8, 10 10, 8 2, 7 8)), POLYGON ((3 8, 10 10, 7 8, 3 8)), POLYGON ((2 2, 8 2, 8.5 1, 2 2)), POLYGON ((2 2, 7 8, 8 2, 2 2)), POLYGON ((2 2, 3 8, 7 8, 2 2)), POLYGON ((0.5 9, 10 10, 3 8, 0.5 9)), POLYGON ((0.5 9, 3 8, 2 2, 0.5 9)), POLYGON ((0 0, 2 2, 8.5 1, 0 0)), POLYGON ((0 0, 0.5 9, 2 2, 0 0)))"))
     collection = GeoInterface.geometries(geomcollection)
@@ -61,8 +61,8 @@ facts("Geo interface") do
                                              Vector{Vector{Float64}}[Vector{Float64}[[0.5,9.0],[ 3.0, 8.0],[2.0,2.0],[0.5,9.0]]],
                                              Vector{Vector{Float64}}[Vector{Float64}[[0.0,0.0],[ 2.0, 2.0],[8.5,1.0],[0.0,0.0]]],
                                              Vector{Vector{Float64}}[Vector{Float64}[[0.0,0.0],[ 0.5, 9.0],[2.0,2.0],[0.0,0.0]]]]
-    @fact map(GeoInterface.coordinates,collection) --> coords
-    @fact GeoInterface.geotype(geomcollection) --> :GeometryCollection
+    @test map(GeoInterface.coordinates,collection) == coords
+    @test GeoInterface.geotype(geomcollection) == :GeometryCollection
 
     geomcollection = LibGEOS.GeometryCollection(LibGEOS.geomFromWKT("GEOMETRYCOLLECTION(MULTIPOINT(0 0, 0 0, 1 1),LINESTRING(1 1, 2 2, 2 2, 0 0),POLYGON((5 5, 0 0, 0 2, 2 2, 5 5)))"))
     collection = GeoInterface.geometries(geomcollection)
@@ -71,13 +71,13 @@ facts("Geo interface") do
                     Vector{Vector{Float64}}[Vector{Float64}[[5.0,5.0],[0.0,0.0],[0.0,2.0],[2.0,2.0],[5.0,5.0]]]]
     geotypes = [:MultiPoint,:LineString,:Polygon]
     for (i,item) in enumerate(collection)
-        @fact GeoInterface.coordinates(item) --> coords[i]
-        @fact GeoInterface.geotype(item) --> geotypes[i]
+        @test GeoInterface.coordinates(item) == coords[i]
+        @test GeoInterface.geotype(item) == geotypes[i]
     end
-    @fact GeoInterface.geotype(geomcollection) --> :GeometryCollection
+    @test GeoInterface.geotype(geomcollection) == :GeometryCollection
 
     geomcollection = LibGEOS.GeometryCollection(LibGEOS.geomFromWKT("GEOMETRYCOLLECTION EMPTY"))
     collection = GeoInterface.geometries(geomcollection)
-    @fact length(collection) --> 0
-    @fact GeoInterface.geotype(geomcollection) --> :GeometryCollection
+    @test length(collection) == 0
+    @test GeoInterface.geotype(geomcollection) == :GeometryCollection
 end