Add more tests

Author: gdalle

src/MetaGraphsNext.jl

@@ -5,7 +5,8 @@ using Graphs
 using SimpleTraits
 
 export MetaGraph
-export label_for, code_for, set_data!
+export label_for, code_for, labels
+export set_data!
 export weighttype, default_weight, get_weight_function
 export MGFormat, DOTFormat
 

src/graphs.jl

@@ -47,30 +47,6 @@ function Base.issubset(meta_graph::MetaGraph, h::MetaGraph)
     return issubset(meta_graph.graph, h.graph)
 end
 
-## Link between graph codes and metagraph labels
-
-"""
-    code_for(meta_graph::MetaGraph, label)
-
-Find the vertex code (or index) associated with label `label`.
-
-This can be useful to pass to methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
-"""
-function code_for(meta_graph::MetaGraph, label)
-    return meta_graph.vertex_properties[label][1]
-end
-
-"""
-    label_for(meta_graph::MetaGraph, code)
-
-Find the label associated with code `code`.
-
-This can be useful to interpret the results of methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
-"""
-function label_for(meta_graph::MetaGraph, code::Integer)
-    return meta_graph.vertex_labels[code]
-end
-
 ## Set vertex and edge data
 
 """

src/metagraph.jl

@@ -43,6 +43,8 @@ struct MetaGraph{
     default_weight::Weight
 end
 
+## Constructors
+
 """
     MetaGraph(
         graph,
@@ -175,6 +177,8 @@ function MetaGraph(
     )
 end
 
+## Base extensions
+
 function Base.show(
     io::IO, meta_graph::MetaGraph{<:Any,<:Any,Label,VertexData,EdgeData}
 ) where {Label,VertexData,EdgeData}
@@ -199,3 +203,36 @@ function Base.:(==)(meta_graph_1::MetaGraph, meta_graph_2::MetaGraph)
         (meta_graph_1.default_weight == meta_graph_2.default_weight)
     )
 end
+
+## Link between graph codes and metagraph labels
+
+"""
+    code_for(meta_graph::MetaGraph, label)
+
+Find the vertex code (or index) associated with label `label`.
+
+This can be useful to pass to methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
+"""
+function code_for(meta_graph::MetaGraph, label)
+    return meta_graph.vertex_properties[label][1]
+end
+
+"""
+    label_for(meta_graph::MetaGraph, code)
+
+Find the label associated with code `code`.
+
+This can be useful to interpret the results of methods inherited from `Graphs`. Note, however, that vertex codes can be reassigned after vertex deletion.
+"""
+function label_for(meta_graph::MetaGraph, code::Integer)
+    return meta_graph.vertex_labels[code]
+end
+
+"""
+    labels(meta_graph::MetaGraph)
+
+List all vertex labels, *not necessarily in the same order as the codes!*
+"""
+function labels(meta_graph::MetaGraph)
+    return values(meta_graph.vertex_labels)
+end

src/weights.jl

@@ -64,12 +64,11 @@ function Base.getindex(meta_weights::MetaWeights, code_1::Integer, code_2::Integ
     if has_edge(meta_graph, code_1, code_2)
         labels = meta_graph.vertex_labels
         weight_function = get_weight_function(meta_graph)
-        weight_function(
-            meta_graph[arrange(
-                meta_graph, labels[code_1], labels[code_2], code_1, code_2
-            )...],
+        arranged_label_1, arranged_label_2 = arrange(
+            meta_graph, labels[code_1], labels[code_2], code_1, code_2
         )
+        return weight_function(meta_graph[arranged_label_1, arranged_label_2])
     else
-        default_weight(meta_graph)
+        return default_weight(meta_graph)
     end
 end

test/labels_codes_directedness.jl

@@ -10,10 +10,10 @@ using Test
     @testset verbose = true "Code quality (Aqua.jl)" begin
         Aqua.test_all(MetaGraphsNext; ambiguities=false)
     end
-    @testset verbose = true "Code formatting (JuliaFormatter.jl)" begin
+    @testset verbose = false "Code formatting (JuliaFormatter.jl)" begin
         @test format(MetaGraphsNext; verbose=false, overwrite=false)
     end
-    @testset verbose = true "Doctests (Documenter.jl)" begin
+    @testset verbose = false "Doctests (Documenter.jl)" begin
         doctest(MetaGraphsNext)
     end
     @testset verbose = true "Tutorial" begin
@@ -27,7 +27,4 @@ using Test
             include(joinpath("tutorial", "3_files.jl"))
         end
     end
-    @testset verbose = true "Labels, codes, directedness" begin
-        include("labels_codes_directedness.jl")
-    end
 end

test/runtests.jl

@@ -16,9 +16,33 @@ colors = MetaGraph(
     graph_data="additive colors",  # tag for the whole graph
 )
 
+@test_throws ErrorException @inferred MetaGraph(  #src
+    Graph();  #src
+    label_type=Symbol,  #src
+    vertex_data_type=NTuple{3,Int},  #src
+    edge_data_type=String,  #src
+    graph_data="additive colors",  #src
+)  #src
+
 # The `label_type` argument defines how vertices will be referred to, it can be anything but an integer type (to avoid confusion with codes, see below). The `vertex_data_type` and `edge_data_type` type determine what kind of data will be associated with each vertex and edge. Finally, `graph_data` can contain an arbitrary object associated with the graph as a whole.
 
-# However, since this constructor receives types as keyword arguments, it is type-unstable. Casual users may not care, but if your goal is performance, you should use the following syntax instead, which relies on positional arguments.
+# However, since this constructor receives types as keyword arguments, it is type-unstable. Casual users may not care, but if your goal is performance, you should use either of the following alternatives:
+# 1. Wrap the constructor in a function
+# 2. Switch to positional arguments (be careful with the order!)
+
+function colors_constructor()
+    return MetaGraph(
+        Graph();
+        label_type=Symbol,
+        vertex_data_type=NTuple{3,Int},
+        edge_data_type=String,
+        graph_data="additive colors",
+    )
+end
+
+@test @inferred colors_constructor() == colors  #src
+
+#-
 
 colors_stable = MetaGraph(Graph(), Symbol, NTuple{3,Int}, String, "additive colors")
 
@@ -28,9 +52,7 @@ colors_stable = MetaGraph(Graph(), Symbol, NTuple{3,Int}, String, "additive colo
     NTuple{3,Int},  #src
     String,  #src
     "additive colors",  #src
-) == colors_stable  #src
-
-# Be careful with the order!
+) == colors  #src
 
 # ## Modifying the graph
 
@@ -103,39 +125,69 @@ label_for(colors, 1)
 label_for(colors, 3)
 @test label_for(colors, 3) == :blue  #src
 
-# ## Adding weights
+# Test coherence  #src
 
-# The most simple way to add edge weights is to speficy a default weight for all of them.
+for label in labels(colors)  #src
+    @test label_for(colors, code_for(colors, label)) == label  #src
+end  #src
 
-weighted_default = MetaGraph(Graph(); label_type=Symbol, default_weight=2);
-#-
-default_weight(weighted_default)
-@test @inferred default_weight(weighted_default) == 2  #src
-#-
-weighttype(weighted_default)
-@test @inferred weighttype(weighted_default) == Int  #src
+for code in vertices(colors)  #src
+    @test code_for(colors, label_for(colors, code)) == code  #src
+end  #src
+
+# Delete vertex in a copy and test again  #src
 
-# You can use the `weight_function` keyword to specify a function which will transform edge metadata into a weight. This weight must always be the same type as the `default_weight`.
+colors_copy = copy(colors)  #src
+rem_vertex!(colors_copy, 1)  #src
+
+for label in labels(colors_copy)  #src
+    @test label_for(colors_copy, code_for(colors_copy, label)) == label  #src
+end  #src
+
+for code in vertices(colors_copy)  #src
+    @test code_for(colors_copy, label_for(colors_copy, code)) == code  #src
+end  #src
+
+# ## Handling weights
+
+# You can use the `weight_function` field to specify a function which will transform edge metadata into a weight. This weight must always have the same type as the `default_weight`, which is the value returned in case an edge does not exist.
 
 weighted = MetaGraph(
-    Graph(); label_type=Symbol, edge_data_type=Float64, weight_function=ed -> ed^2
+    Graph();
+    label_type=Symbol,
+    edge_data_type=Float64,
+    weight_function=ed -> ed^2,
+    default_weight=Inf,
 );
 
 weighted[:alice] = nothing;
 weighted[:bob] = nothing;
+weighted[:charlie] = nothing;
+
 weighted[:alice, :bob] = 2.0;
+weighted[:bob, :charlie] = 3.0;
 #-
 weight_matrix = Graphs.weights(weighted)
 @test @inferred Graphs.weights(weighted) == weight_matrix
 #-
+default_weight(weighted)
+@test @inferred default_weight(weighted) ≈ Inf  #src
+#-
 size(weight_matrix)
-@test size(weight_matrix) == (2, 2)  #src
+@test size(weight_matrix) == (3, 3)  #src
 #-
 weight_matrix[1, 2]
 @test @inferred weight_matrix[1, 2] ≈ 4.0  #src
 #-
+weight_matrix[2, 3]
+@test @inferred weight_matrix[2, 3] ≈ 9.0  #src
+#-
+weight_matrix[1, 3]
+@test @inferred weight_matrix[1, 3] ≈ Inf  #src
+#-
 wf = get_weight_function(weighted)
-wf(3)
-@test @inferred wf(3) == 9  #src
+@test @inferred get_weight_function(weighted) == wf
+wf(4.0)
+@test @inferred wf(4.0) ≈ 16.0  #src
 
 # You can then use all functions from Graphs.jl that require weighted graphs (see the rest of the tutorial).

test/tutorial/1_basics.jl

@@ -33,6 +33,8 @@ cities[:Paris, :Berlin] = 878;
 
 is_directed(cities)
 @test @inferred !is_directed(cities)  #src
+@test !istrait(IsDirected{typeof(cities)})  #src
+@test MetaGraphsNext.arrange(cities, :London, :Paris) == (:Paris, :London)
 #-
 eltype(cities)
 @test @inferred eltype(cities) == Int  #src
@@ -119,6 +121,8 @@ rock_paper_scissors[:paper, :rock] = "paper beats rock";
 
 is_directed(rock_paper_scissors)
 @test @inferred is_directed(rock_paper_scissors)  #src
+@test istrait(IsDirected{typeof(rock_paper_scissors)}) #src
+@test MetaGraphsNext.arrange(rock_paper_scissors, :paper, :rock) == (:paper, :rock)  #src
 
 # Directed graphs can be reversed: