more tests for basic_types.jl

Author: ffreyer

src/basic_types.jl

@@ -337,6 +337,7 @@ end
 Base.getindex(mp::MultiPolygon, i) = mp.polygons[i]
 Base.size(mp::MultiPolygon) = size(mp.polygons)
 Base.length(mp::MultiPolygon) = length(mp.polygons)
+Base.:(==)(a::MultiPolygon, b::MultiPolygon) = a.polygons == b.polygons
 
 """
     LineString(points::AbstractVector{<:Point})
@@ -361,6 +362,7 @@ end
 Base.getindex(ms::MultiLineString, i) = ms.linestrings[i]
 Base.size(ms::MultiLineString) = size(ms.linestrings)
 Base.length(mpt::MultiLineString) = length(mpt.linestrings)
+Base.:(==)(a::MultiLineString, b::MultiLineString) = a.linestrings == b.linestrings
 
 """
     MultiPoint(points::AbstractVector{AbstractPoint})

test/geometrytypes.jl

@@ -204,16 +204,19 @@ end
     @test values(ns) ≈ Vec3f[[0.9805807, 0.0, 0.19611615], [0.0, 0.9805807, 0.19611615], [-0.9805807, 0.0, 0.19611615], [0.0, -0.9805807, 0.19611615], [0.0, 0.0, -1.0]]
 end
 
-NFace = NgonFace
+@testset "Type Utils" begin
+    @test GeometryBasics.Face(TriangleFace, Int32) == TriangleFace{Int32}
+    @test GeometryBasics.Face(GLTriangleFace, Int32) == TriangleFace{GLIndex}
+end
 
 @testset "Faces" begin
     @test convert_simplex(GLTriangleFace, QuadFace{Int}(1, 2, 3, 4)) ==
           (GLTriangleFace(1, 2, 3), GLTriangleFace(1, 3, 4))
-    @test convert_simplex(NFace{3,ZeroIndex{Int}}, QuadFace{ZeroIndex{Int}}(1, 2, 3, 4)) ==
-          (NFace{3,ZeroIndex{Int}}(1, 2, 3), NFace{3,ZeroIndex{Int}}(1, 3, 4))
-    @test convert_simplex(NFace{3,OffsetInteger{3,Int}},
-                          NFace{4,OffsetInteger{2,Int}}(1, 2, 3, 4)) ==
-          (NFace{3,OffsetInteger{3,Int}}(1, 2, 3), NFace{3,OffsetInteger{3,Int}}(1, 3, 4))
+    @test convert_simplex(NgonFace{3,ZeroIndex{Int}}, QuadFace{ZeroIndex{Int}}(1, 2, 3, 4)) ==
+          (NgonFace{3,ZeroIndex{Int}}(1, 2, 3), NgonFace{3,ZeroIndex{Int}}(1, 3, 4))
+    @test convert_simplex(NgonFace{3,OffsetInteger{3,Int}},
+                          NgonFace{4,OffsetInteger{2,Int}}(1, 2, 3, 4)) ==
+          (NgonFace{3,OffsetInteger{3,Int}}(1, 2, 3), NgonFace{3,OffsetInteger{3,Int}}(1, 3, 4))
     @test convert_simplex(LineFace{Int}, QuadFace{Int}(1, 2, 3, 4)) ==
           (LineFace{Int}(1, 2), LineFace{Int}(2, 3), LineFace{Int}(3, 4),
            LineFace{Int}(4, 1))
@@ -226,6 +229,33 @@ NFace = NgonFace
         @test convert_simplex(NgonFace{1,UInt32}, face) === (NgonFace{1,UInt32}((1,)),)
         @test convert_simplex(typeof(face), face) === (face,)
     end
+
+    ps = rand(Point2f, 10)
+    f = GLTriangleFace(1, 2, 3)
+    @test ps[f] == Triangle(ps[[1,2,3]]...)
+    data = [string(i) for i in 1:10]
+    f = QuadFace(3, 4, 7, 8)
+    @test data[f] == ("3", "4", "7", "8")
+
+    @test hash(f) != hash(QuadFace(1,2,3,4))
+    @test hash(f) == hash(QuadFace(3,4,7,8))
+    # cyclic permutation does not change the face
+    @test hash(f) == hash(QuadFace(7,8,3,4))
+    @test hash(GLTriangleFace(1,2,3)) == hash(GLTriangleFace(1,2,3))
+    @test hash(GLTriangleFace(1,2,3)) == hash(GLTriangleFace(2,3,1))
+    @test hash(GLTriangleFace(1,2,3)) == hash(GLTriangleFace(3,1,2))
+end
+
+@testset "FaceView" begin
+    ps = rand(Point2f, 5)
+    fs = GLTriangleFace[(1,2,3), (2,3,4), (5,5,5)]
+    fv = FaceView(ps, fs)
+    @test faces(fv) == fs
+    @test values(fv) == ps
+    @test fv[fs[1]] == ps[fs[1]]
+    @test !isempty(fv)
+    @test fv == FaceView(ps, fs)
+    @test length(fv) == 5
 end
 
 @testset "Normals" begin
@@ -253,7 +283,6 @@ end
     v_ns = normals(coordinates(c), filter!(f -> f isa QuadFace, faces(c)))[1:end-2]
     @test values(ns)[1:15] ≈ v_ns[1:15]
     @test values(ns)[1:15] ≈ v_ns[16:30] # repeated via FaceView in ns
-
 end
 
 @testset "HyperSphere" begin
@@ -455,4 +484,32 @@ end
     r = Rect2i(2, 4, 2, 4)
     @test M[r] == [53 63 73 83; 54 64 74 84]
 
+end
+
+@testset "LineStrings" begin
+    ps1 = rand(Point2f, 10)
+    ls1 = LineString(ps1)
+    _ls1 = LineString(ps1)
+    @test coordinates(ls1) == ps1
+    @test length(ls1) == 10
+    @test ls1 == _ls1
+
+    ls2 = LineString(rand(Point2f, 6))
+    ls3 = LineString(rand(Point2f, 4))
+    mls = MultiLineString([ls1, ls2, ls3])
+    @test mls.linestrings == [ls1, ls2, ls3]
+    @test mls[1] == ls1
+    @test mls[2] == ls2
+    @test mls[3] == ls3
+    @test size(mls) == (3, ) # TODO: Does this make sense?
+    @test length(mls) == 3
+    @test MultiLineString(OffsetArray([ls1, ls2, ls3], 0)) == mls
+end
+
+@testset "MultiPoint" begin
+    ps1 = rand(Point2f, 10)
+    mp = MultiPoint(ps1)
+    @test all(getindex.(Ref(mp), 1:10) .== ps1)
+    @test size(mp) == (10, ) # TODO: Does this make sense?
+    @test length(mp) == 10
 end

test/meshes.jl

@@ -173,22 +173,50 @@ end
     @test hasproperty(m, :uv)
     @test hasproperty(m, :faces)
 
+    @test GeometryBasics.meta(m) == NamedTuple()
+    @test Mesh(m) === m
+
     mm = MetaMesh(m, name = "test")
 
     @test Mesh(mm) == m
     @test haskey(mm, :name)
     @test get(mm, :name, nothing) == "test"
+    @test get(() -> nothing, mm, :name) == "test"
+    @test get(mm, :foo, nothing) === nothing
+    @test get(() -> nothing, mm, :foo) === nothing
     @test mm[:name] == "test"
     @test !haskey(mm, :foo)
-    @test get!(mm, :foo, "bar") == "bar"
+    @test get!(mm, :foo, "foo") == "foo"
     @test haskey(mm, :foo)
+    @test get!(() -> "bar", mm, :bar) == "bar"
+    @test haskey(mm, :bar)
+    mm[:foo] = "bar"
+    @test mm[:foo] == "bar"
+    delete!(mm, :bar)
+    @test !haskey(mm, :bar)
     @test keys(mm) == keys(getfield(mm, :meta))
 
     @test vertex_attributes(mm) == getfield(m, :vertex_attributes)
     @test coordinates(mm) == vertex_attributes(m)[:position]
     @test normals(mm) == vertex_attributes(m)[:normal]
     @test texturecoordinates(mm) == vertex_attributes(m)[:uv]
     @test faces(mm) == getfield(m, :faces)
+
+    @test hasproperty(mm, :vertex_attributes)
+    @test hasproperty(mm, :position)
+    @test hasproperty(mm, :normal)
+    @test hasproperty(mm, :uv)
+    @test hasproperty(mm, :faces)
+    @test propertynames(mm) == (:mesh, :meta, propertynames(m)...)
+
+    @test mm.vertex_attributes == getfield(m, :vertex_attributes)
+    @test mm.position == vertex_attributes(m)[:position]
+    @test mm.normal == vertex_attributes(m)[:normal]
+    @test mm.uv == vertex_attributes(m)[:uv]
+    @test mm.faces == getfield(m, :faces)
+
+    @test GeometryBasics.meta(mm) == mm.meta
+    @test Mesh(mm) === mm.mesh
 end
 
 @testset "mesh() constructors" begin

test/polygons.jl

@@ -1,8 +1,29 @@
 @testset "Polygon" begin
-    @testset "from points" begin
+    @testset "Constructors" begin
         points = connect([1, 2, 3, 4, 5, 6], Point2f)
         polygon = Polygon(points)
         @test polygon == Polygon(points)
+        @test polygon == copy(polygon)
+        @test coordinates(polygon) == points
+        @test Polygon(OffsetArray(points)) == polygon
+
+        interiors = [rand(Point2f, 4), rand(Point2f, 4)]
+        exterior = rand(Point2f, 5)
+        p1 = Polygon(exterior, interiors)
+        @test p1.interiors == interiors
+        @test p1.exterior == exterior
+        p2 = Polygon(OffsetArray(exterior, 0), interiors)
+        @test p2 == p1
+
+        # TODO: promote polygon type automatically
+        polygon = Polygon(Point2f.(points))
+        mp = MultiPolygon([polygon, p1, p2])
+        @test mp.polygons == [polygon, p1, p2]
+        @test mp[1] == polygon
+        @test mp[2] == p1
+        @test size(mp) == (3,) # TODO: What does size even mean here?
+        @test length(mp) == 3
+        @test MultiPolygon(OffsetArray([polygon, p1, p2], 0)) == mp
     end
 
     rect = Rect2f(0, 0, 1, 1)

test/runtests.jl

@@ -92,6 +92,9 @@ end
         tetrahedra = connect(x, NSimplex{4})
         @test tetrahedra == [Tetrahedron(x[1], x[2], x[3], x[4])]
 
+        @test length(tetrahedra[1]) == 4
+        @test all(coordinates(tetrahedra[1]) .== x)
+
         @testset "matrix non-copy point views" begin
             # point in row
             points = [1 2; 1 4; 66 77]
@@ -237,36 +240,43 @@ end
     @test GeometryBasics.faces(m) isa Vector{GLTriangleFace}
 end
 
-@testset "lines intersects" begin
+@testset "Lines" begin
     a = Line(Point(0.0, 0.0), Point(4.0, 1.0))
     b = Line(Point(0.0, 0.25), Point(3.0, 0.25))
     c = Line(Point(0.0, 0.25), Point(0.5, 0.25))
     d = Line(Point(0.0, 0.0), Point(0.0, 4.0))
     e = Line(Point(1.0, 0.0), Point(0.0, 4.0))
     f = Line(Point(5.0, 0.0), Point(6.0, 0.0))
 
-    @test intersects(a, b) === (true, Point(1.0, 0.25))
-    @test intersects(a, c) === (false, Point(0.0, 0.0))
-    @test intersects(d, d) === (false, Point(0.0, 0.0))
-    found, point = intersects(d, e)
-    @test found && point ≈ Point(0.0, 4.0)
-    @test intersects(a, f) === (false, Point(0.0, 0.0))
-
-    # issue #168
-    # If these tests fail then you can increase the tolerance on the checks so
-    # long as you know what you're doing :)
-    line_helper(a, b, c, d) = Line(Point(a, b), Point(c, d))
-    b, loc = intersects(line_helper(-3.1, 15.588457268119894, 3.1, 15.588457268119894),
-                        line_helper(2.0866025403784354, 17.37050807568877, -4.0866025403784505, 13.806406460551015))
-    @test b
-    @test loc ≈ Point(-1.0000000000000058, 15.588457268119894)
-
-    b, loc = intersects(line_helper(5743.933982822018, 150.0, 5885.355339059327, -50.0),
-                        line_helper(5760.0, 100.0, 5760.0, 140.0))
-    @test b
-    @test loc ≈ Point(5760.0, 127.27922061357884)
+    multi_line = [a,b,c,d,e,f]
+    @test coordinates(multi_line) == vcat([[x.points...] for x in multi_line]...)
+
+    @testset "intersects" begin
+        @test intersects(a, b) === (true, Point(1.0, 0.25))
+        @test intersects(a, c) === (false, Point(0.0, 0.0))
+        @test intersects(d, d) === (false, Point(0.0, 0.0))
+        found, point = intersects(d, e)
+        @test found && point ≈ Point(0.0, 4.0)
+        @test intersects(a, f) === (false, Point(0.0, 0.0))
+
+        # issue #168
+        # If these tests fail then you can increase the tolerance on the checks so
+        # long as you know what you're doing :)
+        line_helper(a, b, c, d) = Line(Point(a, b), Point(c, d))
+        b, loc = intersects(line_helper(-3.1, 15.588457268119894, 3.1, 15.588457268119894),
+                            line_helper(2.0866025403784354, 17.37050807568877, -4.0866025403784505, 13.806406460551015))
+        @test b
+        @test loc ≈ Point(-1.0000000000000058, 15.588457268119894)
+
+        b, loc = intersects(line_helper(5743.933982822018, 150.0, 5885.355339059327, -50.0),
+                            line_helper(5760.0, 100.0, 5760.0, 140.0))
+        @test b
+        @test loc ≈ Point(5760.0, 127.27922061357884)
+    end
 end
 
+
+
 @testset "Offsetintegers" begin
     x = 1
     @test GeometryBasics.raw(x) isa Int