remove unnecessary tests

Author: casteryh

tests/unit_tests/rl/test_language_reward.py

@@ -18,11 +18,6 @@ def setUp(self):
         self.LanguageReward = LanguageReward
         self.reward_en = LanguageReward(target_language="en")
         self.reward_ja = LanguageReward(target_language="ja")
-        self.custom_reward = LanguageReward(
-            target_language="ja",
-            match_reward=0.9,
-            no_match_reward=0.1,
-        )
 
     def test_init_default_values(self):
         """Test LanguageReward initialization with default values."""
@@ -97,9 +92,7 @@ def test_call_with_chinese_thinking(self):
 
     def test_call_with_spanish_thinking(self):
         """Test __call__ with Spanish text in thinking blocks."""
-        response = (
-            "<思考>Este es un razonamiento en español sobre problemas matemáticos.</思考>"
-        )
+        response = "<思考>Este es un razonamiento en español sobre problemas matemáticos.</思考>"
         reward_es = self.LanguageReward(target_language="es")
         result = reward_es("prompt", response)
         # langid should detect this as Spanish (es)
@@ -152,12 +145,6 @@ def test_call_with_proper_tags(self):
         result = self.reward_ja("prompt", response)
         self.assertEqual(result, 1.0)
 
-    def test_call_with_whitespace_in_tags(self):
-        """Test __call__ with whitespace in thinking tags."""
-        response = "< 思考 >This is English reasoning.</ 思考 >"
-        result = self.reward_en("prompt", response)
-        self.assertEqual(result, 1.0)
-
     def test_call_multiple_thinking_blocks(self):
         """Test __call__ with multiple thinking blocks - detects whole response language."""
         response = """
@@ -169,17 +156,6 @@ def test_call_multiple_thinking_blocks(self):
         # Multiple blocks -> detect whole response, English detected -> match_reward
         self.assertEqual(result, 1.0)
 
-    def test_call_multiple_thinking_blocks_mixed_languages(self):
-        """Test __call__ with multiple thinking blocks in different languages."""
-        response = """
-        <思考>First thought in English with lots of content here.</思考>
-        <思考>これは短い日本語。</思考>
-        """
-        result = self.reward_en("prompt", response)
-        # Multiple blocks -> detect whole response, langid will detect dominant language
-        # Should return match_reward (1.0) if English dominant, or no_match_reward (0.0) if not
-        self.assertIn(result, [0.0, 1.0])
-
     def test_call_multiline_thinking_block(self):
         """Test __call__ with multiline thinking blocks."""
         response = """<思考>
@@ -201,20 +177,6 @@ def test_call_none_response(self):
         result = self.reward_en("prompt", None)
         self.assertEqual(result, 0.0)
 
-    def test_call_with_target_parameter(self):
-        """Test __call__ with target parameter (should be ignored)."""
-        response = "<思考>This is English reasoning.</思考>"
-        result = self.reward_en("prompt", response, target="some target")
-        self.assertEqual(result, 1.0)
-
-        # English text without tags -> detect whole response -> match_reward
-        result = self.reward_en(
-            "prompt",
-            "This is a response without thinking tags but in English language.",
-            target="some target",
-        )
-        self.assertEqual(result, 1.0)
-
     def test_call_custom_reward_values(self):
         """Test __call__ with custom reward values."""
         response_ja_single = "<思考>これは日本語です。</思考>"
@@ -223,24 +185,21 @@ def test_call_custom_reward_values(self):
         response_en = "<思考>This is English.</思考>"
         response_none = ""
 
+        custom_reward = LanguageReward(
+            target_language="ja",
+            match_reward=0.9,
+            no_match_reward=0.1,
+        )
         # Test custom match reward (single block, correct language)
-        self.assertEqual(self.custom_reward("prompt", response_ja_single), 0.9)
+        self.assertEqual(custom_reward("prompt", response_ja_single), 0.9)
         # Test custom match reward (multiple blocks -> whole response, correct language)
-        self.assertEqual(self.custom_reward("prompt", response_ja_multiple), 0.9)
+        self.assertEqual(custom_reward("prompt", response_ja_multiple), 0.9)
         # Test custom match reward (no blocks -> whole response, correct language)
-        self.assertEqual(self.custom_reward("prompt", response_ja_no_tags), 0.9)
+        self.assertEqual(custom_reward("prompt", response_ja_no_tags), 0.9)
         # Test custom no_match reward (wrong language)
-        self.assertEqual(self.custom_reward("prompt", response_en), 0.1)
+        self.assertEqual(custom_reward("prompt", response_en), 0.1)
         # Test empty response
-        self.assertEqual(self.custom_reward("prompt", response_none), 0.1)
-
-    def test_call_zero_custom_values(self):
-        """Test __call__ with zero custom values."""
-        zero_reward = self.LanguageReward(
-            target_language="en", match_reward=0.0, no_match_reward=0.0
-        )
-        result = zero_reward("prompt", "<思考>This is English.</思考>")
-        self.assertEqual(result, 0.0)
+        self.assertEqual(custom_reward("prompt", response_none), 0.1)
 
     def test_call_with_special_characters(self):
         """Test __call__ with special characters in thinking blocks."""
@@ -269,12 +228,6 @@ def test_call_with_numbers_and_symbols(self):
         # Should still detect as English due to words like "Calculate" and "then"
         self.assertEqual(result, 1.0)
 
-    def test_call_very_long_thinking_block(self):
-        """Test __call__ with very long thinking blocks."""
-        long_content = "This is English content. " * 1000
-        result = self.reward_en("prompt", f"<思考>{long_content}</思考>")
-        self.assertEqual(result, 1.0)
-
     def test_call_with_code_in_thinking(self):
         """Test __call__ with code snippets in thinking blocks."""
         response = """<思考>