🚨 Improve tests of CRP

Author: ronisbr

test/crp.jl

@@ -6,6 +6,8 @@
 
 # == File: ./src/crp.jl ====================================================================
 
+# -- Functions: CRP ------------------------------------------------------------------------
+
 @testset "CRP Constructors" begin
     c = CRP(1.0, 2.0, 3.0)
     @test c.q1 == 1.0
@@ -29,29 +31,48 @@
     @test c.q2 == 0
     @test c.q3 == 0
 
-    # Test indexing and iteration
     @test c[1] == 0
     @test c[2] == 0
     @test c[3] == 0
     @test collect(c) == [0, 0, 0]
     @test length(c) == 3
 end
 
+# -- Functions: show -----------------------------------------------------------------------
+
 @testset "CRP Show" begin
-    # c = CRP(1.0, 2.0, 3.0)
-    # io = IOBuffer()
-    # show(io, c)
-    # s = String(take!(io))
-    # @test occursin("CRP{Float64}", s)
-    # @test occursin("1.0", s)
-    # @test occursin("2.0", s)
-    # @test occursin("3.0", s)
+    buf = IOBuffer()
+    io  = IOContext(buf)
+    c   = CRP(1.0, -2.0, 3.0)
+
+    # Extended printing.
+    show(io, MIME"text/plain"(), c)
+    expected = """
+        CRP{Float64}:
+          X : + 1.0
+          Y : - 2.0
+          Z : + 3.0"""
+    @test String(take!(io.io)) == expected
+
+    # Compact printing.
+    show(io, c)
+    expected = "CRP{Float64}: [1.0, 2.0, 3.0]"
+    @test String(take!(io.io)) == expected
+
+    # Colors.
+    io = IOContext(buf, :color => true)
+    show(io, MIME"text/plain"(), c)
+    expected = """
+        CRP{Float64}:
+          \e[1mX : \e[0m+ 1.0
+          \e[1mY : \e[0m- 2.0
+          \e[1mZ : \e[0m+ 3.0"""
+    @test String(take!(io.io)) == expected
 end
 
+# -- Operators: * --------------------------------------------------------------------------
 
 @testset "CRP Composition" begin
-    # c3 = c2 * c1 (apply c1 then c2) -> R3 = R2 * R1
-
     eul1 = EulerAngles(0.3, 0.2, 0.1, :ZYX)
     eul2 = EulerAngles(-0.2, 0.4, -0.3, :ZYX)
 
@@ -60,121 +81,107 @@ end
 
     c3 = c2 * c1
 
-    # Verify with DCM
-    dcm1 = angle_to_dcm(eul1)
-    dcm2 = angle_to_dcm(eul2)
-    dcm3 = dcm2 * dcm1
-
+    # Verify with DCM.
+    dcm1  = angle_to_dcm(eul1)
+    dcm2  = angle_to_dcm(eul2)
+    dcm3  = dcm2 * dcm1
     dcm_c3 = crp_to_dcm(c3)
     @test maximum(abs.(dcm3 - dcm_c3)) < 1e-12
 
-    # Verify compose_rotation
-    c_comp = compose_rotation(c1, c2) # Apply c1 then c2
-    @test isapprox(c_comp, c3; atol=1e-12)
+    # Verify compose_rotation.
+    c_comp = compose_rotation(c1, c2)
+    @test isapprox(c_comp, c3; atol = 1e-12)
 end
 
+# -- Operators: +, -, *, / ----------------------------------------------------------------
+
 @testset "CRP Arithmetic" begin
     c1 = CRP(1.0, 2.0, 3.0)
     c2 = CRP(0.5, -0.5, 1.0)
 
-    # +
     c3 = c1 + c2
-    @test isapprox(c3.q1, 1.5; atol=1e-12)
-    @test isapprox(c3.q2, 1.5; atol=1e-12)
-    @test isapprox(c3.q3, 4.0; atol=1e-12)
+    @test isapprox(c3.q1, 1.5; atol = 1e-12)
+    @test isapprox(c3.q2, 1.5; atol = 1e-12)
+    @test isapprox(c3.q3, 4.0; atol = 1e-12)
 
-    # - (binary)
     c4 = c1 - c2
     @test c4.q1 == 0.5
     @test c4.q2 == 2.5
     @test c4.q3 == 2.0
 
-    # - (unary)
     c_neg = -c1
     @test c_neg.q1 == -1.0
     @test c_neg.q2 == -2.0
     @test c_neg.q3 == -3.0
 
-    # * (scalar)
     c_scaled = 2.0 * c1
     @test c_scaled.q1 == 2.0
     @test c_scaled.q2 == 4.0
     @test c_scaled.q3 == 6.0
+    @test c1 * 2.0 == c_scaled
 
-    c_scaled2 = c1 * 2.0
-    @test c_scaled2 == c_scaled
-
-    # / (scalar)
     c_div = c1 / 2.0
     @test c_div.q1 == 0.5
     @test c_div.q2 == 1.0
     @test c_div.q3 == 1.5
 end
 
+# -- Operators: inv, /, \ -----------------------------------------------------------------
+
 @testset "CRP Inverse and Division" begin
     c1 = CRP(1.0, 2.0, 3.0)
     c2 = CRP(0.5, -0.5, 1.0)
 
-    # inv
     c_inv = inv(c1)
-    # The inverse of a CRP q is -q
     @test c_inv == -c1
 
-    # Identity
-    # c * inv(c) should be identity (0, 0, 0)
     c_identity = c1 * c_inv
-    @test isapprox(c_identity.q1, 0.0; atol=1e-12)
-    @test isapprox(c_identity.q2, 0.0; atol=1e-12)
-    @test isapprox(c_identity.q3, 0.0; atol=1e-12)
-
-    # / (c1 / c2 = c1 * inv(c2))
-    c_div = c1 / c2
-    c_mult = c1 * inv(c2)
-    @test isapprox(c_div, c_mult)
-
-    # \ (c1 \ c2 = inv(c1) * c2)
-    c_backdiv = c1 \ c2
-    c_mult_back = inv(c1) * c2
-    @test isapprox(c_backdiv, c_mult_back)
+    @test isapprox(c_identity.q1, 0.0; atol = 1e-12)
+    @test isapprox(c_identity.q2, 0.0; atol = 1e-12)
+    @test isapprox(c_identity.q3, 0.0; atol = 1e-12)
+
+    @test isapprox(c1 / c2, c1 * inv(c2))
+    @test isapprox(c1 \ c2, inv(c1) * c2)
 end
 
+# -- Functions: norm, one, zero, copy, vect -----------------------------------------------
+
 @testset "CRP Utils" begin
     c = CRP(3.0, 0.0, 4.0)
     @test norm(c) == 5.0
 
-    @test one(CRP) == CRP(0.0, 0.0, 0.0)
-    @test one(c) == CRP(0.0, 0.0, 0.0)
-
+    @test one(CRP)  == CRP(0.0, 0.0, 0.0)
+    @test one(c)    == CRP(0.0, 0.0, 0.0)
     @test zero(CRP) == CRP(0.0, 0.0, 0.0)
-    @test zero(c) == CRP(0.0, 0.0, 0.0)
+    @test zero(c)   == CRP(0.0, 0.0, 0.0)
 
-    # copy
     c_copy = copy(c)
     @test c_copy == c
 
-    # vect
     v = vect(c)
     @test v isa SVector{3, Float64}
     @test v[1] == c.q1
     @test v[2] == c.q2
     @test v[3] == c.q3
 
-    # UniformScaling
-    @test I * c == c
-    @test c * I == c
-    @test I / c == inv(c)
-    @test c / I == c
-    @test I \ c == c
-    @test c \ I == inv(c)
+    @test I * c  == c
+    @test c * I  == c
+    @test I / c  == inv(c)
+    @test c / I  == c
+    @test I \ c  == c
+    @test c \ I  == inv(c)
 end
 
+# -- Functions: shadow_rotation -----------------------------------------------------------
+
 @testset "CRP Shadow Rotation" begin
     c = CRP(1.0, 2.0, 3.0)
     c_shadow = shadow_rotation(c)
-
     @test c == c_shadow
 end
 
+# -- Functions: rand -----------------------------------------------------------------------
+
 @testset "CRP Random" begin
     Random.seed!(123)
     c = rand(CRP)
@@ -184,30 +191,25 @@ end
     @test c_float32 isa CRP{Float32}
 end
 
+# -- Functions: dcrp -----------------------------------------------------------------------
+
 @testset "CRP Kinematics" begin
-    # Test analytical derivative against numerical derivative
     for T in (Float64,)
-        # We need a seed to ensure reproducibility
         Random.seed!(123)
 
-        c = rand(CRP{T})
-        w = @SVector randn(T, 3)
-
+        c  = rand(CRP{T})
+        w  = @SVector randn(T, 3)
         dc = dcrp(c, w)
 
         dt = 1e-8
 
-        # Use DCM to propagate
-        D = crp_to_dcm(c)
-        dD = ddcm(D, w)
-        D_next = D + dD * dt
-        D_next = orthonormalize(D_next)
+        D      = crp_to_dcm(c)
+        dD     = ddcm(D, w)
+        D_next = orthonormalize(D + dD * dt)
 
         c_next = dcm_to_crp(D_next)
-
         dc_num = (c_next - c) / dt
 
-        # Check alignment
-        @test isapprox(dc, dc_num; rtol = 1e-4, atol=1e-6)
+        @test isapprox(dc, dc_num; rtol = 1e-4, atol = 1e-6)
     end
-end
+end