test(flows): consolidate None tests and add falsy-value parametrize cases

Per reviewer feedback: collapse the two near-identical None tests into a
single @pytest.mark.parametrize test, and add falsy-but-not-None cases
(0, '', {}, False) to prove the sentinel is identity-based and does not
mishandle any falsy return value from a FunctionTool.

Author: Koushik-Salammagari

tests/unittests/flows/llm_flows/test_functions_thread_pool.py

@@ -278,52 +278,38 @@ def blocking_sleep() -> dict:
     ), f'Event loop should have ticked at least 5 times, got {event_loop_ticks}'
 
   @pytest.mark.asyncio
-  async def test_sync_tool_returning_none_executes_exactly_once(self):
-    """Test that a sync FunctionTool returning None is not double-executed.
+  @pytest.mark.parametrize(
+      'return_value,use_implicit_return',
+      [
+          (None, True),   # implicit None (no return statement)
+          (None, False),  # explicit `return None`
+          (0, False),     # falsy int
+          ('', False),    # falsy str
+          ({}, False),    # falsy dict
+          (False, False), # falsy bool
+      ],
+  )
+  async def test_sync_tool_falsy_return_executes_exactly_once(
+      self, return_value, use_implicit_return
+  ):
+    """FunctionTools returning None or other falsy values must execute exactly once.
 
     Regression test for https://github.com/google/adk-python/issues/5284.
-    A FunctionTool whose underlying function returns None (e.g. side-effect-
-    only tools with no explicit return statement) must execute exactly once.
-    Previously the None return was mistaken for the internal sentinel used to
+    Previously, a None return was mistaken for the internal sentinel used to
     signal 'non-FunctionTool, fall back to run_async', causing a second
-    invocation via tool.run_async().
+    invocation. The fix uses an identity-based sentinel so that None and other
+    falsy values (0, '', {}, False) are treated as valid results.
     """
     call_count = 0
 
-    def side_effect_only() -> None:
+    def sync_func():
       nonlocal call_count
       call_count += 1
-      # No return statement — implicit None.
+      if not use_implicit_return:
+        return return_value
+      # implicit None — no return statement
 
-    tool = FunctionTool(side_effect_only)
-    model = testing_utils.MockModel.create(responses=[])
-    agent = Agent(name='test_agent', model=model, tools=[tool])
-    invocation_context = await testing_utils.create_invocation_context(
-        agent=agent, user_content=''
-    )
-    tool_context = ToolContext(
-        invocation_context=invocation_context,
-        function_call_id='test_id',
-    )
-
-    result = await _call_tool_in_thread_pool(tool, {}, tool_context)
-
-    assert result is None
-    assert call_count == 1, (
-        f'Tool function executed {call_count} time(s); expected exactly 1.'
-    )
-
-  @pytest.mark.asyncio
-  async def test_sync_tool_returning_explicit_none_executes_exactly_once(self):
-    """Test that explicit None return from FunctionTool is not double-executed."""
-    call_count = 0
-
-    def explicit_none_return() -> None:
-      nonlocal call_count
-      call_count += 1
-      return None  # Explicit None return.
-
-    tool = FunctionTool(explicit_none_return)
+    tool = FunctionTool(sync_func)
     model = testing_utils.MockModel.create(responses=[])
     agent = Agent(name='test_agent', model=model, tools=[tool])
     invocation_context = await testing_utils.create_invocation_context(
@@ -336,7 +322,7 @@ def explicit_none_return() -> None:
 
     result = await _call_tool_in_thread_pool(tool, {}, tool_context)
 
-    assert result is None
+    assert result == return_value
     assert call_count == 1, (
         f'Tool function executed {call_count} time(s); expected exactly 1.'
     )