diff --git a/Project.toml b/Project.toml
index ece22c6..f80e856 100644
--- a/Project.toml
+++ b/Project.toml
@@ -10,7 +10,7 @@ Random = "9a3f8284-a2c9-5f02-9a11-845980a1fd5c"
 SparseArrays = "2f01184e-e22b-5df5-ae63-d93ebab69eaf"
 
 [compat]
-ColPack_jll = "0.4.1"
+ColPack_jll = "=0.4.3"
 LinearAlgebra = "1.10"
 Random = "1.10"
 SparseArrays = "1.10"
diff --git a/gen/Project.toml b/gen/Project.toml
new file mode 100644
index 0000000..fbdf66b
--- /dev/null
+++ b/gen/Project.toml
@@ -0,0 +1,8 @@
+[deps]
+ColPack_jll = "f218ff0c-cb54-5151-80c4-c0f62c730ce6"
+Clang = "40e3b903-d033-50b4-a0cc-940c62c95e31"
+JuliaFormatter = "98e50ef6-434e-11e9-1051-2b60c6c9e899"
+
+[compat]
+ColPack_jll = "0.4.3"
+julia = "1.10"
diff --git a/gen/README.md b/gen/README.md
new file mode 100644
index 0000000..29efbc3
--- /dev/null
+++ b/gen/README.md
@@ -0,0 +1,9 @@
+# Wrapping headers
+
+This directory contains a script that can be used to automatically generate wrappers from C headers provided by ColPack.
+This is done using Clang.jl.
+
+# Usage
+
+Either run `julia --project wrapper.jl` directly, or include it and call the function `main()`.
+Be sure to activate the project environment in this folder (`julia --project`), which will install `Clang.jl` and `JuliaFormatter.jl`.
diff --git a/gen/colpack.toml b/gen/colpack.toml
new file mode 100644
index 0000000..d6317a7
--- /dev/null
+++ b/gen/colpack.toml
@@ -0,0 +1,12 @@
+[general]
+use_julia_native_enum_type = true
+print_using_CEnum = false
+library_name = "libcolpack"
+
+[codegen]
+use_julia_bool = true
+always_NUL_terminated_string = false
+use_ccall_macro = true
+
+[codegen.macro]
+macro_mode = "disable"
diff --git a/gen/wrapper.jl b/gen/wrapper.jl
new file mode 100644
index 0000000..8841244
--- /dev/null
+++ b/gen/wrapper.jl
@@ -0,0 +1,32 @@
+# Script to parse CUTEst headers and generate Julia wrappers.
+using ColPack_jll
+using Clang
+using Clang.Generators
+using JuliaFormatter
+
+# Add cinterface.h in the next release of ColPack_jll.jl!
+function main()
+  cd(@__DIR__)
+  include_dir = joinpath(ColPack_jll.artifact_dir, "include")
+  # headers = joinpath(include_dir, "cinterface.h")
+  headers = joinpath("..", "..", "ColPack", "src", "Utilities", "cinterface.h")
+
+  options = load_options(joinpath(@__DIR__, "colpack.toml"))
+  options["general"]["output_file_path"] = joinpath("..", "src", "libcolpack.jl")
+  options["general"]["output_ignorelist"] = []
+
+  args = get_default_args()
+  push!(args, "-I$include_dir")
+
+  ctx = create_context(headers, args, options)
+  build!(ctx)
+
+  path = options["general"]["output_file_path"]
+  format_file(path, YASStyle())
+  return nothing
+end
+
+# If we want to use the file as a script with `julia wrapper.jl`
+if abspath(PROGRAM_FILE) == @__FILE__
+  main()
+end
diff --git a/src/ColPack.jl b/src/ColPack.jl
index 1a8c357..5c664d1 100644
--- a/src/ColPack.jl
+++ b/src/ColPack.jl
@@ -9,8 +9,11 @@ A Julia interface to the C++ library [ColPack](https://github.com/CSCsw/ColPack)
 - [`ColPackPartialColoring`](@ref)
 - [`ColPackBiColoring`](@ref)
 - [`colpack`](@ref)
+- [`get_ordering`](@ref)
 - [`get_colors`](@ref)
 - [`ncolors`](@ref)
+- [`timer_ordering`](@ref)
+- [`timer_coloring`](@ref)
 """
 module ColPack
 
@@ -32,6 +35,6 @@ include("colpack_bicoloring.jl")
 
 # Exports
 
-export ColPackColoring, ColPackPartialColoring, ColPackBiColoring, colpack, get_colors, ncolors
+export ColPackColoring, ColPackPartialColoring, ColPackBiColoring, colpack, get_ordering, get_colors, ncolors, timer_ordering, timer_coloring
 
 end #module
diff --git a/src/colpack_bicoloring.jl b/src/colpack_bicoloring.jl
index 01f03b6..1bcecab 100644
--- a/src/colpack_bicoloring.jl
+++ b/src/colpack_bicoloring.jl
@@ -35,6 +35,7 @@ The fields of this struct are not part of the public API, they are only useful t
 """
 mutable struct ColPackBiColoring
     refColPack::Base.RefValue{Ptr{Cvoid}}
+    ordering::Vector{Cint}
     coloring1::Vector{Cint}
     coloring2::Vector{Cint}
     method::String
@@ -59,9 +60,10 @@ function ColPackBiColoring(
         refColPack, reflen1, reflen2, filename, method, order, verbose
     )
     (ret == 0) && error("ColPack bicoloring failed.")
+    ordering = zeros(Cint, reflen1[] + reflen2[])
     coloring1 = zeros(Cint, reflen1[])
     coloring2 = zeros(Cint, reflen2[])
-    g = ColPackBiColoring(refColPack, coloring1, coloring2, method, order)
+    g = ColPackBiColoring(refColPack, ordering, coloring1, coloring2, method, order)
     finalizer(free_bicoloring, g)
     return g
 end
@@ -81,31 +83,42 @@ function ColPackBiColoring(
     nrows, ncols = size(M)
 
     # Version adolc
-    # Mᵀ = sparse(M')
-    # adolc, adolc_mem = csr_to_adolc(Mᵀ)
-    # ret = build_bicoloring_from_adolc(refColPack, reflen1, reflen2, adolc, nrows, ncols, method, order, verbose)
+    Mᵀ = sparse(M')
+    adolc, adolc_mem = csr_to_adolc(Mᵀ)
+    ret = build_bicoloring_from_adolc(refColPack, reflen1, reflen2, adolc, nrows, ncols, method, order, verbose)
 
     # Version csc
     # ColPack expects sparse CSC / CSR matrices with 0-based indexing.
-    rowval = Cint.(M.rowval) .- Cint(1)
-    colptr = Cint.(M.colptr) .- Cint(1)
-    ret = build_bicoloring_from_csc(refColPack, reflen1, reflen2, rowval, colptr, nrows, ncols, method, order, verbose)
-
+    # rowval = Cint.(M.rowval) .- Cint(1)
+    # colptr = Cint.(M.colptr) .- Cint(1)
+    # ret = build_bicoloring_from_csc(refColPack, reflen1, reflen2, rowval, colptr, nrows, ncols, method, order, verbose)
     (ret == 0) && error("ColPack partial coloring failed.")
+    ordering = zeros(Cint, reflen1[] + reflen2[])
     coloring1 = zeros(Cint, reflen1[])
     coloring2 = zeros(Cint, reflen2[])
-    g = ColPackBiColoring(refColPack, coloring1, coloring2, method, order)
+    g = ColPackBiColoring(refColPack, ordering, coloring1, coloring2, method, order)
     finalizer(free_partial_coloring, g)
     return g
 end
 
+"""
+    get_ordering(coloring::ColPackBiColoring)
+
+Retrieve the ordering from a [`ColPackBiColoring`](@ref) as a vector of integers.
+"""
+function get_ordering(coloring::ColPackBiColoring)
+    order_bicoloring(coloring.refColPack[], coloring.ordering)
+    coloring.ordering .+= Cint(1)
+    return coloring.ordering
+end
+
 """
     get_colors(coloring::ColPackBiColoring)
 
 Retrieve the colors from a [`ColPackBiColoring`](@ref) as two vectors of integers, one for the rows and one for the columns respectively.
 """
 function get_colors(coloring::ColPackBiColoring)
-    get_bicoloring(coloring.refColPack[], coloring.coloring1, coloring.coloring2)
+    colors_bicoloring(coloring.refColPack[], coloring.coloring1, coloring.coloring2)
     #=
     Zero is a neutral color in bicoloring, it may make sense to keep it.
     I am not yet sure how the coloring vectors are defined.
@@ -123,3 +136,21 @@ Retrieve the number of colors from a [`ColPackBiColoring`](@ref).
 function ncolors(coloring::ColPackBiColoring)
     return ncolors_bicoloring(coloring.refColPack[])
 end
+
+"""
+    timer_ordering(coloring::ColPackBiColoring)
+
+Retrieve the timer for ordering from a [`ColPackBiColoring`](@ref).
+"""
+function timer_ordering(coloring::ColPackBiColoring)
+    return timer_order_bicoloring(coloring.refColPack[])
+end
+
+"""
+    timer_coloring(coloring::ColPackBiColoring)
+
+Retrieve the timer for coloring from a [`ColPackBiColoring`](@ref).
+"""
+function timer_coloring(coloring::ColPackBiColoring)
+    return timer_colors_bicoloring(coloring.refColPack[])
+end
diff --git a/src/colpack_coloring.jl b/src/colpack_coloring.jl
index 8841be8..e7e2aa2 100644
--- a/src/colpack_coloring.jl
+++ b/src/colpack_coloring.jl
@@ -50,6 +50,7 @@ The fields of this struct are not part of the public API, they are only useful t
 """
 mutable struct ColPackColoring
     refColPack::Base.RefValue{Ptr{Cvoid}}
+    ordering::Vector{Cint}
     coloring::Vector{Cint}
     method::String
     order::String
@@ -70,8 +71,9 @@ function ColPackColoring(
     reflen = Ref{Cint}(0)
     ret = build_coloring_from_file(refColPack, reflen, filename, method, order, verbose)
     (ret == 0) && error("ColPack coloring failed.")
+    ordering = zeros(Cint, reflen[])
     coloring = zeros(Cint, reflen[])
-    g = ColPackColoring(refColPack, coloring, method, order)
+    g = ColPackColoring(refColPack, ordering, coloring, method, order)
     finalizer(free_coloring, g)
     return g
 end
@@ -95,20 +97,31 @@ function ColPackColoring(
     refColPack = Ref{Ptr{Cvoid}}(C_NULL)
     ret = build_coloring_from_adolc(refColPack, reflen, adolc, nrows, method, order, verbose)
     (ret == 0) && error("ColPack coloring failed.")
-
+    ordering = zeros(Cint, reflen[])
     coloring = zeros(Cint, reflen[])
-    g = ColPackColoring(refColPack, coloring, method, order)
+    g = ColPackColoring(refColPack, ordering, coloring, method, order)
     finalizer(free_coloring, g)
     return g
 end
 
+"""
+    get_ordering(coloring::ColPackColoring)
+
+Retrieve the ordering from a [`ColPackColoring`](@ref) as a vector of integers.
+"""
+function get_ordering(coloring::ColPackColoring)
+    order_coloring(coloring.refColPack[], coloring.ordering)
+    coloring.ordering .+= Cint(1)
+    return coloring.ordering
+end
+
 """
     get_colors(coloring::ColPackColoring)
 
 Retrieve the colors from a [`ColPackColoring`](@ref) as a vector of integers.
 """
 function get_colors(coloring::ColPackColoring)
-    get_coloring(coloring.refColPack[], coloring.coloring)
+    colors_coloring(coloring.refColPack[], coloring.coloring)
     coloring.coloring .+= Cint(1)
     return coloring.coloring
 end
@@ -121,3 +134,21 @@ Retrieve the number of colors from a [`ColPackColoring`](@ref).
 function ncolors(coloring::ColPackColoring)
     return ncolors_coloring(coloring.refColPack[])
 end
+
+"""
+    timer_ordering(coloring::ColPackColoring)
+
+Retrieve the timer for ordering from a [`ColPackColoring`](@ref).
+"""
+function timer_ordering(coloring::ColPackColoring)
+    return timer_order_coloring(coloring.refColPack[])
+end
+
+"""
+    timer_coloring(coloring::ColPackColoring)
+
+Retrieve the timer for coloring from a [`ColPackColoring`](@ref).
+"""
+function timer_coloring(coloring::ColPackColoring)
+    return timer_colors_coloring(coloring.refColPack[])
+end
diff --git a/src/colpack_partial_coloring.jl b/src/colpack_partial_coloring.jl
index 94783d6..573794c 100644
--- a/src/colpack_partial_coloring.jl
+++ b/src/colpack_partial_coloring.jl
@@ -52,6 +52,7 @@ The fields of this struct are not part of the public API, they are only useful t
 """
 mutable struct ColPackPartialColoring
     refColPack::Base.RefValue{Ptr{Cvoid}}
+    ordering::Vector{Cint}
     coloring::Vector{Cint}
     method::String
     order::String
@@ -76,8 +77,9 @@ function ColPackPartialColoring(
         refColPack, reflen, filename, method, order, verbose
     )
     (ret == 0) && error("ColPack partial coloring failed.")
+    ordering = zeros(Cint, reflen[])
     coloring = zeros(Cint, reflen[])
-    g = ColPackPartialColoring(refColPack, coloring, method, order)
+    g = ColPackPartialColoring(refColPack, ordering, coloring, method, order)
     finalizer(free_partial_coloring, g)
     return g
 end
@@ -96,30 +98,46 @@ function ColPackPartialColoring(
     nrows, ncols = size(M)
 
     # Version adolc
-    # Mᵀ = sparse(M')
-    # adolc, adolc_mem = csr_to_adolc(Mᵀ)
-    # ret = build_partial_coloring_from_adolc(refColPack, reflen, adolc, nrows, ncols, method, order, verbose)
+    Mᵀ = sparse(M')
+    adolc, adolc_mem = csr_to_adolc(Mᵀ)
+    ret = build_partial_coloring_from_adolc(refColPack, reflen, adolc, nrows, ncols, method, order, verbose)
 
     # Version csc
     # ColPack expects sparse CSC / CSR matrices with 0-based indexing.
-    rowval = Cint.(M.rowval) .- Cint(1)
-    colptr = Cint.(M.colptr) .- Cint(1)
-    ret = build_partial_coloring_from_csc(refColPack, reflen, rowval, colptr, nrows, ncols, method, order, verbose)
-
+    # rowval = Cint.(M.rowval) .- Cint(1)
+    # colptr = Cint.(M.colptr) .- Cint(1)
+    # ret = build_partial_coloring_from_csc(refColPack, reflen, rowval, colptr, nrows, ncols, method, order, verbose)
     (ret == 0) && error("ColPack partial coloring failed.")
+    ordering = zeros(Cint, reflen[])
     coloring = zeros(Cint, reflen[])
-    g = ColPackPartialColoring(refColPack, coloring, method, order)
+    g = ColPackPartialColoring(refColPack, ordering, coloring, method, order)
     finalizer(free_partial_coloring, g)
     return g
 end
 
+"""
+    get_ordering(coloring::ColPackPartialColoring)
+
+Retrieve the ordering from a [`ColPackPartialColoring`](@ref) as a vector of integers.
+"""
+function get_ordering(coloring::ColPackPartialColoring)
+    order_partial_coloring(coloring.refColPack[], coloring.ordering)
+    if coloring.method == "COLUMN_PARTIAL_DISTANCE_TWO"
+        offset = minimum(coloring.ordering) - 1
+        coloring.ordering .-= Cint(offset)
+    else
+        coloring.ordering .+= Cint(1)
+    end
+    return coloring.ordering
+end
+
 """
     get_colors(coloring::ColPackPartialColoring)
 
 Retrieve the colors from a [`ColPackPartialColoring`](@ref) as a vector of integers.
 """
 function get_colors(coloring::ColPackPartialColoring)
-    get_partial_coloring(coloring.refColPack[], coloring.coloring)
+    colors_partial_coloring(coloring.refColPack[], coloring.coloring)
     coloring.coloring .+= Cint(1)
     return coloring.coloring
 end
@@ -132,3 +150,21 @@ Retrieve the number of colors from a [`ColPackPartialColoring`](@ref).
 function ncolors(coloring::ColPackPartialColoring)
     return ncolors_partial_coloring(coloring.refColPack[])
 end
+
+"""
+    timer_ordering(coloring::ColPackPartialColoring)
+
+Retrieve the timer for ordering from a [`ColPackPartialColoring`](@ref).
+"""
+function timer_ordering(coloring::ColPackPartialColoring)
+    return timer_order_partial_coloring(coloring.refColPack[])
+end
+
+"""
+    timer_coloring(coloring::ColPackPartialColoring)
+
+Retrieve the timer for coloring from a [`ColPackPartialColoring`](@ref).
+"""
+function timer_coloring(coloring::ColPackPartialColoring)
+    return timer_colors_partial_coloring(coloring.refColPack[])
+end
diff --git a/src/libcolpack.jl b/src/libcolpack.jl
index b9adf4b..0f60038 100644
--- a/src/libcolpack.jl
+++ b/src/libcolpack.jl
@@ -141,20 +141,56 @@ function build_bicoloring_from_csc(
     )::Cint
 end
 
-function get_coloring(ref, coloring)
-    @ccall libcolpack.get_coloring(ref::Ptr{Cvoid}, coloring::Ptr{Cint})::Cvoid
+function order_coloring(ref, ordering)
+    @ccall libcolpack.order_coloring(ref::Ptr{Cvoid}, ordering::Ptr{Cint})::Cvoid
 end
 
-function get_partial_coloring(ref, coloring)
-    @ccall libcolpack.get_partial_coloring(ref::Ptr{Cvoid}, coloring::Ptr{Cint})::Cvoid
+function order_partial_coloring(ref, ordering)
+    @ccall libcolpack.order_partial_coloring(ref::Ptr{Cvoid}, ordering::Ptr{Cint})::Cvoid
 end
 
-function get_bicoloring(ref, left_coloring, right_coloring)
-    @ccall libcolpack.get_bicoloring(
+function order_bicoloring(ref, ordering)
+    @ccall libcolpack.order_bicoloring(ref::Ptr{Cvoid}, ordering::Ptr{Cint})::Cvoid
+end
+
+function timer_order_coloring(ref)
+    @ccall libcolpack.timer_order_coloring(ref::Ptr{Cvoid})::Cdouble
+end
+
+function timer_order_partial_coloring(ref)
+    @ccall libcolpack.timer_order_partial_coloring(ref::Ptr{Cvoid})::Cdouble
+end
+
+function timer_order_bicoloring(ref)
+    @ccall libcolpack.timer_order_bicoloring(ref::Ptr{Cvoid})::Cdouble
+end
+
+function colors_coloring(ref, coloring)
+    @ccall libcolpack.colors_coloring(ref::Ptr{Cvoid}, coloring::Ptr{Cint})::Cvoid
+end
+
+function colors_partial_coloring(ref, coloring)
+    @ccall libcolpack.colors_partial_coloring(ref::Ptr{Cvoid}, coloring::Ptr{Cint})::Cvoid
+end
+
+function colors_bicoloring(ref, left_coloring, right_coloring)
+    @ccall libcolpack.colors_bicoloring(
         ref::Ptr{Cvoid}, left_coloring::Ptr{Cint}, right_coloring::Ptr{Cint}
     )::Cvoid
 end
 
+function timer_colors_coloring(ref)
+    @ccall libcolpack.timer_colors_coloring(ref::Ptr{Cvoid})::Cdouble
+end
+
+function timer_colors_partial_coloring(ref)
+    @ccall libcolpack.timer_colors_partial_coloring(ref::Ptr{Cvoid})::Cdouble
+end
+
+function timer_colors_bicoloring(ref)
+    @ccall libcolpack.timer_colors_bicoloring(ref::Ptr{Cvoid})::Cdouble
+end
+
 function ncolors_coloring(ref)
     @ccall libcolpack.ncolors_coloring(ref::Ptr{Cvoid})::Cint
 end
diff --git a/src/options.jl b/src/options.jl
index d167407..e194775 100644
--- a/src/options.jl
+++ b/src/options.jl
@@ -10,8 +10,10 @@ const COLORING_METHODS = [
     "ACYCLIC",
     "ACYCLIC_FOR_INDIRECT_RECOVERY",
     "STAR",
+    "NAIVE_STAR",
     "RESTRICTED_STAR",
     "DISTANCE_TWO",
+    # "TRIANGULAR",
 ]
 
 const COLORING_ORDERS = [
@@ -21,25 +23,23 @@ const COLORING_ORDERS = [
     "SMALLEST_LAST",
     "DYNAMIC_LARGEST_FIRST",
     "INCIDENCE_DEGREE",
+    "DISTANCE_TWO_SMALLEST_LAST",
+    "DISTANCE_TWO_LARGEST_FIRST",
+    "DISTANCE_TWO_INCIDENCE_DEGREE",
 ]
 
 ## Partial coloring on bipartite graphs
 
 const PARTIAL_COLORING_METHODS = [
-    "COLUMN_PARTIAL_DISTANCE_TWO",  #
+    "COLUMN_PARTIAL_DISTANCE_TWO",
     "ROW_PARTIAL_DISTANCE_TWO",
 ]
 
-#=
-Was DYNAMIC_LARGEST_FIRST forgotten in the source code?
-https://github.com/CSCsw/ColPack/blob/9a7293a8dfd66a60434496b8df5ebb4274d70339/src/BipartiteGraphPartialColoring/BipartiteGraphPartialOrdering.cpp#L1859-L1938
-=#
-
 const PARTIAL_COLORING_ORDERS = [
     "NATURAL",
     "RANDOM",
     "LARGEST_FIRST",
-    # "DYNAMIC_LARGEST_FIRST",  
+    "DYNAMIC_LARGEST_FIRST",
     "SMALLEST_LAST",
     "INCIDENCE_DEGREE",
 ]
@@ -60,4 +60,7 @@ const BICOLORING_ORDERS = [
     "DYNAMIC_LARGEST_FIRST",
     "SMALLEST_LAST",
     "INCIDENCE_DEGREE",
+    # "SELECTIVE_LARGEST_FIRST",
+    # "SELECTIVE_SMALLEST_LAST",
+    # "SELECTIVE_INCIDENCE_DEGREE",
 ]
diff --git a/test/coloring.jl b/test/coloring.jl
index 9528a2b..983cd65 100644
--- a/test/coloring.jl
+++ b/test/coloring.jl
@@ -12,14 +12,14 @@ using Test
 rng = StableRNG(63)
 
 asymmetric_params = vcat(
-    [(10, 20, p) for p in (0.0:0.1:1.0)],  #
+    [(10, 20, p) for p in (0.0:0.1:1.0)],
     [(20, 10, p) for p in (0.0:0.1:1.0)],
-    [(100, 200, p) for p in (0.01:0.01:0.05)],  #
+    [(100, 200, p) for p in (0.01:0.01:0.05)],
     [(200, 100, p) for p in (0.01:0.01:0.05)],
 )
 
 symmetric_params = vcat(
-    [(10, p) for p in (0.0:0.1:1.0)], #
+    [(10, p) for p in (0.0:0.1:1.0)],
     [(100, p) for p in (0.01:0.01:0.05)],
 )
 
@@ -65,10 +65,17 @@ end
                 @test ncolors(coloring_mat) == ncolors(coloring_file)
                 colors = get_colors(coloring_file)
                 test_colors(H, method, colors)
+                @test get_ordering(coloring_mat) == get_ordering(coloring_file)
+                ordering = get_ordering(coloring_file)
+                @test isperm(ordering)
+                @test timer_ordering(coloring_mat) > 0
+                @test timer_ordering(coloring_file) > 0
+                @test timer_coloring(coloring_mat) > 0
+                @test timer_coloring(coloring_file) > 0
             end
         end
     end
-end;
+end
 
 @testset verbose = true "Bipartite graph partial coloring" begin
     @testset "$method" for method in PARTIAL_COLORING_METHODS
@@ -81,17 +88,29 @@ end;
                 coloring_file = ColPackPartialColoring(
                     filename, method, order; verbose=false
                 )
-                @test length(get_colors(coloring_mat)) == length(get_colors(coloring_file))
-                @test ncolors(coloring_mat) ≥ 1
-                @test ncolors(coloring_file) ≥ 1
-                # this is not always true since we use different algorithms
-                # @test get_colors(coloring_mat) == get_colors(coloring_file)
-                test_colors(J, method, get_colors(coloring_mat))
-                test_colors(J, method, get_colors(coloring_file))
+                @test get_ordering(coloring_mat) == get_ordering(coloring_file)
+                ordering = get_ordering(coloring_file)
+                valid_ordering = isperm(ordering)
+                if order != "LARGEST_FIRST"
+                    @test valid_ordering
+                end
+                if valid_ordering
+                    @test length(get_colors(coloring_mat)) == length(get_colors(coloring_file))
+                    @test ncolors(coloring_mat) ≥ 1
+                    @test ncolors(coloring_file) ≥ 1
+                    # this is not always true since we use different algorithms
+                    # @test get_colors(coloring_mat) == get_colors(coloring_file)
+                    test_colors(J, method, get_colors(coloring_mat))
+                    test_colors(J, method, get_colors(coloring_file))
+                    @test timer_ordering(coloring_mat) > 0
+                    @test timer_ordering(coloring_file) > 0
+                    @test timer_coloring(coloring_mat) > 0
+                    @test timer_coloring(coloring_file) > 0
+                end
             end
         end
     end
-end;
+end
 
 @testset verbose = true "Bipartite graph bicoloring" begin
     @testset "$method" for method in BICOLORING_METHODS
@@ -104,7 +123,11 @@ end;
                 @test ncolors(coloring_file) ≥ 1
                 colors1, colors2 = get_colors(coloring_file)
                 test_colors(J, method, colors1, colors2)
+                ordering = get_ordering(coloring_file)
+                @test isperm(ordering)
+                @test timer_ordering(coloring_file) > 0
+                @test timer_coloring(coloring_file) > 0
             end
         end
     end
-end;
+end
diff --git a/test/exceptions.jl b/test/exceptions.jl
index abe53f9..5e8875d 100644
--- a/test/exceptions.jl
+++ b/test/exceptions.jl
@@ -13,9 +13,9 @@ H = sparse(H_dense)
 @test get_colors(ColPackColoring(H, "STAR", "NATURAL")) isa Vector{Int32}
 @test get_colors(ColPackPartialColoring(J, "COLUMN_PARTIAL_DISTANCE_TWO", "NATURAL")) isa
     Vector{Int32}
-@test_broken get_colors(
+@test get_colors(
     ColPackBiColoring(J, "EXPLICIT_COVERING__STAR_BICOLORING", "NATURAL")
-) isa NTuple{Vector{Int32},2}
+) isa Tuple{Vector{Int32}, Vector{Int32}}
 
 ## Error on dense matrix
 
diff --git a/test/runtests.jl b/test/runtests.jl
index 8082efa..e487033 100644
--- a/test/runtests.jl
+++ b/test/runtests.jl
@@ -5,12 +5,10 @@ using JET
 using Test
 
 @testset verbose = true "ColPack" begin
-    if VERSION >= v"1.10"
-        @testset verbose = false "Code quality" begin
-            Aqua.test_all(ColPack)
-            @testset "JET" begin
-                JET.test_package(ColPack; target_defined_modules=true)
-            end
+    @testset verbose = false "Code quality" begin
+        Aqua.test_all(ColPack)
+        @testset "JET" begin
+            JET.test_package(ColPack; target_defined_modules=true)
         end
     end
     @testset "Doctests" begin