diff --git a/test/test_type.jl b/test/test_type.jl
index d13b626b060..be713684148 100644
--- a/test/test_type.jl
+++ b/test/test_type.jl
@@ -121,25 +121,11 @@ isdir(outdir) && rm(outdir, recursive = true)
             @test eltype(@inferred flux_kennedy_gruber(u_ll, u_rr, orientation, equations)) ==
                   RealT
             @test eltype(@inferred flux_hllc(u_ll, u_rr, orientation, equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                                 equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                          equations)) ==
-                      RealT
-            end
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, orientation,
-                                                           equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
-                      RealT
-            end
+            @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
+                                                      equations)) ==
+                  RealT
+            @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
+                  RealT
 
             @test eltype(eltype(@inferred splitting_steger_warming(u, orientation,
                                                                    equations))) ==
@@ -228,26 +214,11 @@ isdir(outdir) && rm(outdir, recursive = true)
                   RealT
             @test eltype(@inferred flux_hllc(u_ll, u_rr, normal_direction, equations)) ==
                   RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr,
-                                                                 normal_direction,
-                                                                 equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, normal_direction,
-                                                          equations)) ==
-                      RealT
-            end
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                           equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                    equations)) == RealT
-            end
+            @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, normal_direction,
+                                                      equations)) ==
+                  RealT
+            @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
+                                                equations)) == RealT
 
             @test eltype(eltype(@inferred splitting_drikakis_tsangaris(u, normal_direction,
                                                                        equations))) == RealT
@@ -282,26 +253,11 @@ isdir(outdir) && rm(outdir, recursive = true)
                       RealT
                 @test eltype(@inferred flux_hllc(u_ll, u_rr, orientation, equations)) ==
                       RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr,
-                                                                     orientation,
-                                                                     equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                              equations)) ==
-                          RealT
-                end
-                if RealT == Float32
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, orientation,
-                                                               equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
-                          RealT
-                end
+                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
+                                                          equations)) ==
+                      RealT
+                @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
+                      RealT
 
                 @test eltype(eltype(@inferred splitting_steger_warming(u, orientation,
                                                                        equations))) ==
@@ -351,7 +307,7 @@ isdir(outdir) && rm(outdir, recursive = true)
 
     @timed_testset "Compressible Euler 3D" begin
         for RealT in (Float32, Float64)
-            # set gamma = 2 for the coupling convergence test 
+            # set gamma = 2 for the coupling convergence test
             equations = @inferred CompressibleEulerEquations3D(RealT(2))
 
             x = SVector(zero(RealT), zero(RealT), zero(RealT))
@@ -400,24 +356,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                   RealT
             @test eltype(@inferred flux_hllc(u_ll, u_rr, normal_direction, equations)) ==
                   RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr,
-                                                                 normal_direction,
-                                                                 equations)) == RealT
-            else
-                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, normal_direction,
-                                                          equations)) == RealT
-            end
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                           equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                    equations)) == RealT
-            end
+            @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, normal_direction,
+                                                      equations)) == RealT
+            @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
+                                                equations)) == RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, normal_direction,
                                                        equations)) ==
@@ -440,24 +382,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                       RealT
                 @test eltype(@inferred flux_hllc(u_ll, u_rr, orientation, equations)) ==
                       RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr,
-                                                                     orientation,
-                                                                     equations)) == RealT
-                else
-                    @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                              equations)) == RealT
-                end
-                if RealT == Float32
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, orientation,
-                                                               equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
-                          RealT
-                end
+                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
+                                                          equations)) == RealT
+                @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
+                      RealT
 
                 @test eltype(eltype(@inferred splitting_steger_warming(u, orientation,
                                                                        equations))) ==
@@ -509,23 +437,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                   RealT
 
             @test eltype(@inferred flux(u, orientation, equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                                 equations)) == RealT
-            else
-                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                          equations)) == RealT
-            end
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, orientation,
-                                                           equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
-                      RealT
-            end
+            @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
+                                                      equations)) == RealT
+            @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
+                  RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation, equations)) ==
                   RealT
@@ -565,34 +480,15 @@ isdir(outdir) && rm(outdir, recursive = true)
                   RealT
 
             @test eltype(@inferred flux(u, normal_direction, equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                           equations)) == RealT
-            else
-                @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
-                                                    equations)) == RealT
-            end
+            @test eltype(@inferred flux_ranocha(u_ll, u_rr, normal_direction,
+                                                equations)) == RealT
 
             for orientation in orientations
                 @test eltype(@inferred flux(u, orientation, equations)) == RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_chandrashekar(u_ll, u_rr,
-                                                                     orientation,
-                                                                     equations)) == RealT
-                else
-                    @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
-                                                              equations)) == RealT
-                end
-                if RealT == Float32
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_ranocha(u_ll, u_rr, orientation,
-                                                               equations)) == RealT
-                else
-                    @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
-                          RealT
-                end
+                @test eltype(@inferred flux_chandrashekar(u_ll, u_rr, orientation,
+                                                          equations)) == RealT
+                @test eltype(@inferred flux_ranocha(u_ll, u_rr, orientation, equations)) ==
+                      RealT
 
                 @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation,
                                                            equations)) ==
@@ -637,15 +533,8 @@ isdir(outdir) && rm(outdir, recursive = true)
             @test eltype(@inferred flux_nonconservative_chan_etal(u_ll, u_rr, normal_ll,
                                                                   normal_rr, equations)) ==
                   RealT
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_chan_etal(u_ll, u_rr, orientation,
-                                                             equations)) ==
-                             RealT
-            else
-                @test eltype(@inferred flux_chan_etal(u_ll, u_rr, orientation, equations)) ==
-                      RealT
-            end
+            @test eltype(@inferred flux_chan_etal(u_ll, u_rr, orientation, equations)) ==
+                  RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation, equations)) ==
                   RealT
@@ -989,21 +878,11 @@ isdir(outdir) && rm(outdir, recursive = true)
 
             @test eltype(@inferred flux(u, orientation, equations)) == RealT
             @test eltype(@inferred flux_hllc(u_ll, u_rr, orientation, equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                               equations)) == RealT
-                # check `ln_mean` and `inv_ln_mean` (test broken) 
-                @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                      orientation,
-                                                                      equations)) == RealT
-            else
-                @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation, equations)) ==
-                      RealT
-                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                               orientation,
-                                                               equations)) == RealT
-            end
+            @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation, equations)) ==
+                  RealT
+            @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
+                                                           orientation,
+                                                           equations)) == RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation, equations)) ==
                   RealT
@@ -1073,15 +952,8 @@ isdir(outdir) && rm(outdir, recursive = true)
                                                                normal_direction_ll,
                                                                normal_direction_average,
                                                                equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                      normal_direction,
-                                                                      equations)) == RealT
-            else
-                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, normal_direction,
-                                                               equations)) == RealT
-            end
+            @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, normal_direction,
+                                                           equations)) == RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, normal_direction,
                                                        equations)) == RealT
@@ -1101,22 +973,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                                                                                    orientation,
                                                                                    equations)) ==
                       RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                                   equations)) ==
-                                 RealT
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                          orientation,
-                                                                          equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                            equations)) == RealT
-                    @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
-                                                                   equations)) == RealT
-                end
+                @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
+                                                        equations)) == RealT
+                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
+                                                               equations)) == RealT
                 for nonconservative_term in nonconservative_terms
                     @test eltype(@inferred flux_nonconservative_powell_local_symmetric(u_ll,
                                                                                        orientation,
@@ -1210,15 +1070,8 @@ isdir(outdir) && rm(outdir, recursive = true)
                                                                normal_direction_ll,
                                                                normal_direction_average,
                                                                equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                      normal_direction,
-                                                                      equations)) == RealT
-            else
-                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, normal_direction,
-                                                               equations)) == RealT
-            end
+            @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, normal_direction,
+                                                           equations)) == RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, normal_direction,
                                                        equations)) == RealT
@@ -1233,22 +1086,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                 @test eltype(@inferred flux(u, orientation, equations)) == RealT
                 @test eltype(@inferred flux_nonconservative_powell(u_ll, u_rr, orientation,
                                                                    equations)) == RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                                   equations)) ==
-                                 RealT
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                          orientation,
-                                                                          equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                            equations)) == RealT
-                    @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
-                                                                   equations)) == RealT
-                end
+                @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
+                                                        equations)) == RealT
+                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
+                                                               equations)) == RealT
 
                 @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation,
                                                            equations)) == RealT
@@ -1318,21 +1159,10 @@ isdir(outdir) && rm(outdir, recursive = true)
                   RealT
 
             @test eltype(@inferred flux(u, orientation, equations)) == RealT
-            if RealT == Float32
-                # check `ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                               equations)) ==
-                             RealT
-                # check `ln_mean` and `inv_ln_mean` (test broken)
-                @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                      orientation,
-                                                                      equations)) == RealT
-            else
-                @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation, equations)) ==
-                      RealT
-                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
-                                                               equations)) == RealT
-            end
+            @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation, equations)) ==
+                  RealT
+            @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
+                                                           equations)) == RealT
 
             @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation, equations)) ==
                   RealT
@@ -1381,22 +1211,11 @@ isdir(outdir) && rm(outdir, recursive = true)
                 @test eltype(@inferred flux_nonconservative_powell(u_ll, u_rr, orientation,
                                                                    equations)) ==
                       RealT
-                if RealT == Float32
-                    # check `ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                                   equations)) == RealT
-                    # check `ln_mean` and `inv_ln_mean` (test broken)
-                    @test_broken eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr,
-                                                                          orientation,
-                                                                          equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
-                                                            equations)) ==
-                          RealT
-                    @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
-                                                                   equations)) == RealT
-                end
+                @test eltype(@inferred flux_derigs_etal(u_ll, u_rr, orientation,
+                                                        equations)) ==
+                      RealT
+                @test eltype(@inferred flux_hindenlang_gassner(u_ll, u_rr, orientation,
+                                                               equations)) == RealT
 
                 @test typeof(@inferred max_abs_speed_naive(u_ll, u_rr, orientation,
                                                            equations)) ==
@@ -2011,17 +1830,9 @@ isdir(outdir) && rm(outdir, recursive = true)
                       RealT
 
                 @test eltype(@inferred flux(u, normal_direction, equations)) == RealT
-                if RealT == Float32
-                    # check `ln_mean` and `stolarsky_mean` (test broken)
-                    @test_broken eltype(@inferred flux_winters_etal(u_ll, u_rr,
-                                                                    normal_direction,
-                                                                    equations)) ==
-                                 RealT
-                else
-                    @test eltype(@inferred flux_winters_etal(u_ll, u_rr, normal_direction,
-                                                             equations)) ==
-                          RealT
-                end
+                @test eltype(@inferred flux_winters_etal(u_ll, u_rr, normal_direction,
+                                                         equations)) ==
+                      RealT
                 @test eltype(@inferred min_max_speed_naive(u_ll, u_rr, normal_direction,
                                                            equations)) ==
                       RealT
@@ -2034,17 +1845,9 @@ isdir(outdir) && rm(outdir, recursive = true)
 
                 for orientation in orientations
                     @test eltype(@inferred flux(u, orientation, equations)) == RealT
-                    if RealT == Float32
-                        # check `ln_mean` and `stolarsky_mean` (test broken)
-                        @test_broken eltype(@inferred flux_winters_etal(u_ll, u_rr,
-                                                                        orientation,
-                                                                        equations)) ==
-                                     RealT
-                    else
-                        @test eltype(@inferred flux_winters_etal(u_ll, u_rr, orientation,
-                                                                 equations)) ==
-                              RealT
-                    end
+                    @test eltype(@inferred flux_winters_etal(u_ll, u_rr, orientation,
+                                                             equations)) ==
+                          RealT
                     @test eltype(@inferred min_max_speed_davis(u_ll, u_rr, orientation,
                                                                equations)) ==
                           RealT
@@ -2124,7 +1927,7 @@ isdir(outdir) && rm(outdir, recursive = true)
             @test eltype(@inferred dissipation(u_ll, u_rr, normal_direction, equations)) ==
                   RealT
             @test eltype(@inferred numflux(u_ll, u_rr, orientation, equations)) == RealT
-            # no matching method 
+            # no matching method
             # @test eltype(@inferred numflux(u_ll, u_rr, normal_direction, equations)) == RealT
             @test eltype(@inferred min_max_speed_naive(u_ll, u_rr, orientation, equations)) ==
                   RealT