refactor: enhance test readability by removing unnecessary blank lines in flow limits tests

Author: madawei2699

test/agent_forge/flow_limits_test.exs

@@ -1,47 +1,49 @@
 defmodule AgentForge.FlowLimitsTest do
   use ExUnit.Case
-  
+
   alias AgentForge.Flow
   alias AgentForge.Signal
-  
+
   describe "process_with_limits/4" do
     test "processes a simple flow without timeout" do
       signal = Signal.new(:test, "data")
       handler = fn sig, state -> {{:emit, Signal.new(:echo, sig.data)}, state} end
-      
+
       {:ok, result, state} = Flow.process_with_limits([handler], signal, %{})
-      
+
       assert result.type == :echo
       assert result.data == "data"
       assert state == %{}
     end
-    
+
     test "enforces timeout for infinite loops" do
       signal = Signal.new(:start, "data")
-      
+
       # Create an infinite loop handler that always emits the same signal
       infinite_loop = fn signal, state ->
-        Process.sleep(100) # Add a small delay to ensure timeout works
+        # Add a small delay to ensure timeout works
+        Process.sleep(100)
         {{:emit, signal}, state}
       end
-      
+
       # Should terminate after timeout
       result = Flow.process_with_limits([infinite_loop], signal, %{}, timeout_ms: 300)
-      
+
       # Verify we got an error
       assert {:error, error_msg, final_state} = result
       assert error_msg =~ "timed out"
-      assert final_state == %{}  # State should be preserved
+      # State should be preserved
+      assert final_state == %{}
     end
-    
+
     test "handles normal termination" do
       signal = Signal.new(:test, "data")
-      
+
       # This handler will terminate after 3 steps
       counter_handler = fn signal, state ->
         counter = Map.get(state, :counter, 0) + 1
         new_state = Map.put(state, :counter, counter)
-        
+
         if counter >= 3 do
           # Terminate after 3 steps
           {{:halt, "done after #{counter} steps"}, new_state}
@@ -50,14 +52,14 @@ defmodule AgentForge.FlowLimitsTest do
           {{:emit, Signal.new(:"step_#{counter}", signal.data)}, new_state}
         end
       end
-      
+
       # Should complete normally
       {:ok, result, final_state} = Flow.process_with_limits([counter_handler], signal, %{})
-      
+
       assert result == "done after 3 steps"
       assert final_state.counter == 3
     end
-    
+
     test "handles multiple signal emissions" do
       signal = Signal.new(:test, "data")
 
@@ -68,15 +70,17 @@ defmodule AgentForge.FlowLimitsTest do
           Signal.new(:second, "two"),
           Signal.new(:third, "three")
         ]
+
         {{:emit_many, signals}, state}
       end
 
       {:ok, result, _state} = Flow.process_with_limits([multi_emit], signal, %{})
 
-      assert result.type == :third  # Should continue with the last signal
+      # Should continue with the last signal
+      assert result.type == :third
       assert result.data == "three"
     end
-    
+
     test "handles errors in handlers" do
       signal = Signal.new(:test, "data")
 
@@ -89,9 +93,10 @@ defmodule AgentForge.FlowLimitsTest do
       {:error, error_msg, state} = Flow.process_with_limits([error_handler], signal, %{})
 
       assert error_msg == "Handler error"
-      assert state == %{}  # State should be preserved
+      # State should be preserved
+      assert state == %{}
     end
-    
+
     test "respects handler skip response" do
       signal = Signal.new(:test, "data")