Add direct test coverage for _kld_BalanceDF, _emd_BalanceDF, _cvmd_BalanceDF, and _ks_BalanceDF

Co-authored-by: talgalili <976006+talgalili@users.noreply.github.com>

Author: Copilot

tests/test_balancedf.py

@@ -1301,6 +1301,146 @@ def test_BalanceDF_asmd_aggregate_by_main_covar(self) -> None:
         self.assertEqual(outcome_default, expected_default)
         self.assertEqual(outcome_main_covar, expected_main_covar)
 
+    def test_BalanceDF__kld_BalanceDF(self) -> None:
+        """Test _kld_BalanceDF static method directly."""
+        sample = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (1, 2), "b": (-1, 12), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        target = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (3, 4), "b": (0, 42), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        result = BalanceDF._kld_BalanceDF(sample, target)
+        
+        # Verify result is a Series with expected keys
+        self.assertIsInstance(result, pd.Series)
+        self.assertIn("a", result.index)
+        self.assertIn("b", result.index)
+        self.assertIn("mean(kld)", result.index)
+        
+        # Verify all values are non-negative (KLD property)
+        self.assertTrue((result >= 0).all())
+        
+        # Test with aggregate_by_main_covar
+        result_agg = BalanceDF._kld_BalanceDF(sample, target, aggregate_by_main_covar=True)
+        self.assertIsInstance(result_agg, pd.Series)
+
+    def test_BalanceDF__emd_BalanceDF(self) -> None:
+        """Test _emd_BalanceDF static method directly."""
+        sample = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (1, 2), "b": (-1, 12), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        target = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (3, 4), "b": (0, 42), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        result = BalanceDF._emd_BalanceDF(sample, target)
+        
+        # Verify result is a Series with expected keys
+        self.assertIsInstance(result, pd.Series)
+        self.assertIn("a", result.index)
+        self.assertIn("b", result.index)
+        self.assertIn("mean(emd)", result.index)
+        
+        # Verify all values are non-negative (EMD property)
+        self.assertTrue((result >= 0).all())
+        
+        # Test with aggregate_by_main_covar
+        result_agg = BalanceDF._emd_BalanceDF(sample, target, aggregate_by_main_covar=True)
+        self.assertIsInstance(result_agg, pd.Series)
+
+    def test_BalanceDF__cvmd_BalanceDF(self) -> None:
+        """Test _cvmd_BalanceDF static method directly."""
+        sample = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (1, 2), "b": (-1, 12), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        target = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (3, 4), "b": (0, 42), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        result = BalanceDF._cvmd_BalanceDF(sample, target)
+        
+        # Verify result is a Series with expected keys
+        self.assertIsInstance(result, pd.Series)
+        self.assertIn("a", result.index)
+        self.assertIn("b", result.index)
+        self.assertIn("mean(cvmd)", result.index)
+        
+        # Verify all values are non-negative (CVMD property)
+        self.assertTrue((result >= 0).all())
+        
+        # Test with aggregate_by_main_covar
+        result_agg = BalanceDF._cvmd_BalanceDF(sample, target, aggregate_by_main_covar=True)
+        self.assertIsInstance(result_agg, pd.Series)
+
+    def test_BalanceDF__ks_BalanceDF(self) -> None:
+        """Test _ks_BalanceDF static method directly."""
+        sample = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (1, 2), "b": (-1, 12), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        target = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (3, 4), "b": (0, 42), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        result = BalanceDF._ks_BalanceDF(sample, target)
+        
+        # Verify result is a Series with expected keys
+        self.assertIsInstance(result, pd.Series)
+        self.assertIn("a", result.index)
+        self.assertIn("b", result.index)
+        self.assertIn("mean(ks)", result.index)
+        
+        # Verify all values are in [0, 1] (KS property)
+        self.assertTrue((result >= 0).all())
+        self.assertTrue((result <= 1).all())
+        
+        # Test with aggregate_by_main_covar
+        result_agg = BalanceDF._ks_BalanceDF(sample, target, aggregate_by_main_covar=True)
+        self.assertIsInstance(result_agg, pd.Series)
+
+    def test_BalanceDF_comparison_functions_invalid_input(self) -> None:
+        """Test that all comparison functions properly validate inputs."""
+        sample = Sample.from_frame(
+            pd.DataFrame(
+                {"id": (1, 2), "a": (1, 2), "weight": (1, 2)}
+            )
+        ).covars()
+        
+        # Test with non-BalanceDF inputs
+        invalid_input = "not a BalanceDF"
+        
+        with self.assertRaisesRegex(ValueError, "must be balancedf_class.BalanceDF"):
+            BalanceDF._kld_BalanceDF(invalid_input, sample)  # type: ignore
+        
+        with self.assertRaisesRegex(ValueError, "must be balancedf_class.BalanceDF"):
+            BalanceDF._emd_BalanceDF(sample, invalid_input)  # type: ignore
+        
+        with self.assertRaisesRegex(ValueError, "must be balancedf_class.BalanceDF"):
+            BalanceDF._cvmd_BalanceDF(invalid_input, sample)  # type: ignore
+        
+        with self.assertRaisesRegex(ValueError, "must be balancedf_class.BalanceDF"):
+            BalanceDF._ks_BalanceDF(sample, invalid_input)  # type: ignore
+
 
 class TestBalanceDF_to_download(BalanceTestCase):
     def test_BalanceDF_to_download(self) -> None: