update tests

Author: borisdevos

test/runtests.jl

@@ -15,6 +15,7 @@ istestfile(fn) = endswith(fn, ".jl") && startswith(basename(fn), "test_") &&
                  !contains(fn, "setup")
 
 include("setup.jl")
+using .TestSetup
 
 @time begin
     # tests in groups based on folder structure

test/setup.jl

@@ -1,3 +1,7 @@
+module TestSetup
+
+export unitarity_test, rand_object, random_fusion, eval_show
+
 using MultiTensorKit
 using TensorKitSectors
 using Random
@@ -6,8 +10,7 @@ const MTK = MultiTensorKit
 
 Random.seed!(1234)
 
-function unitarity_test(as::Vector{I}, bs::Vector{I},
-                        cs::Vector{I}) where {I<:BimoduleSector}
+function unitarity_test(as::Vector{I}, bs::Vector{I},cs::Vector{I}) where {I <: BimoduleSector} # abstractvector?
     @assert all(a.j == b.i for a in as, b in bs)
     @assert all(b.j == c.i for b in bs, c in cs)
 
@@ -19,14 +22,12 @@ function unitarity_test(as::Vector{I}, bs::Vector{I},
             for e in es
                 for f in fs
                     Fs = Fsymbol(a, b, c, d, e, f)
-                    push!(Fblocks,
-                          reshape(Fs,
-                                  (size(Fs, 1) * size(Fs, 2),
-                                   size(Fs, 3) * size(Fs, 4))))
+                    push!(Fblocks, reshape(Fs, (size(Fs, 1) * size(Fs, 2),
+                                                size(Fs, 3) * size(Fs, 4))))
                 end
             end
             F = hvcat(length(fs), Fblocks...)
-            isapprox(F' * F, one(F); atol=1e-12, rtol=1e-12) || return false
+            isapprox(F' * F, one(F); atol = 1.0e-12, rtol = 1.0e-12) || return false
         end
     end
     return true
@@ -37,47 +38,41 @@ all_objects(::Type{<:BimoduleSector}, i::Int, j::Int) = [I(i, j, k) for k in 1:M
 function rand_object(I::Type{<:BimoduleSector}, i::Int, j::Int)
     obs = all_objects(I, i, j)
     ob = rand(obs)
-    if i == j
-        while ob == one(ob) # unit of any fusion cat avoided
-            ob = rand(obs)
-        end
+    while isunit(ob) # unit of any fusion cat avoided
+        ob = rand(obs)
     end
+
     return ob
 end
 
-function random_fusion(I::Type{<:BimoduleSector}, i::Int, j::Int, N::Int) # for fusion tree tests
+function random_fusion(I::Type{<:BimoduleSector}, i::Int, j::Int, ::Val{N}) where {N} # for fusion tree tests
+    N == 1 && return (rand_object(I, i, j),)
+    tail = random_fusion(I, i, j, Val(N - 1))
+    counter = 0
+
     Cs = all_objects(I, i, i)
     Ds = all_objects(I, j, j)
     Ms = all_objects(I, i, j)
     Mops = all_objects(I, j, i)
     allobs = vcat(Cs, Ds, Ms, Mops)
+    s = rand(allobs)
 
-    in = nothing
-    out = nothing
-    while in === nothing
-        out = ntuple(n -> rand(allobs), N)
-        try
-            in = rand(collect(⊗(out...)))
-        catch e
-            if isa(e, AssertionError)
-                in = nothing
-            else
-                rethrow(e)
-            end 
-        end
+    while isempty(⊗(s, first(tail))) && counter < 40
+        counter += 1
+        s = (counter < 40) ? rand(allobs) : leftunit(first(tail))
     end
-    return out
+    return (s, tail...)
 end
 
-# for fusion tree merge test
-function safe_tensor_product(x::I, y::I) where {I<:BimoduleSector}
-    try
-        return x ⊗ y
-    catch e
-        if e isa AssertionError
-            return nothing
-        else
-            rethrow(e)
-        end
-    end
-end
+"""
+    eval_show(x)
+
+Use `show` to generate a string representation of `x`, then parse and evaluate the resulting expression.
+"""
+function eval_show(x)
+    str = sprint(show, x; context = (:module => @__MODULE__))
+    ex = Meta.parse(str)
+    return eval(ex)
+end
+
+end # end of module TestSetup