Refactor LiteRT-LM unsupported-tokenizer tests to @pytest.mark.xfail

pctablet505 · pctablet505 · commit 739af85cb1da · 2026-06-23T11:57:57.000Z
- Removed expected_error_regex handling from run_litertlm_export_test.
- Converted all test_litertlm_export_unsupported_tokenizer methods to
  normal export calls decorated with @pytest.mark.xfail.
- Removed KERAS_BACKEND assignment from qwen3_moe and qwen_moe causal LM
  tests; backend is set externally per KerasHub testing convention.
diff --git a/keras_hub/src/models/bloom/bloom_causal_lm_test.py b/keras_hub/src/models/bloom/bloom_causal_lm_test.py
@@ -176,12 +176,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=BloomCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/falcon/falcon_causal_lm_test.py b/keras_hub/src/models/falcon/falcon_causal_lm_test.py
@@ -176,12 +176,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=FalconCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/gpt_neo_x/gpt_neo_x_causal_lm_test.py b/keras_hub/src/models/gpt_neo_x/gpt_neo_x_causal_lm_test.py
@@ -124,11 +124,11 @@ def test_litert_export(self):
             },  # More lenient thresholds for numerical differences
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         """GPT-NeoX tokenizer is not a supported LiteRT-LM family."""
         self.run_litertlm_export_test(
             cls=GPTNeoXCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex="Cannot infer HuggingFace tokenizer family|Supported families are 'gpt2', 'llama3', and 'qwen3'",
         )
diff --git a/keras_hub/src/models/gpt_oss/gpt_oss_causal_lm_test.py b/keras_hub/src/models/gpt_oss/gpt_oss_causal_lm_test.py
@@ -121,12 +121,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=GptOssCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/opt/opt_causal_lm_test.py b/keras_hub/src/models/opt/opt_causal_lm_test.py
@@ -45,12 +45,12 @@ def setUp(self):
         self.train_data = ([" airplane at airport", " airplane at airport"],)
         self.input_data = self.preprocessor(*self.train_data)[0]
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=OPTCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',
         )
 
     def test_causal_lm_basics(self):
diff --git a/keras_hub/src/models/parseq/parseq_causal_lm_test.py b/keras_hub/src/models/parseq/parseq_causal_lm_test.py
@@ -130,10 +130,10 @@ def test_litert_export(self):
             output_thresholds={"*": {"max": 1e-3, "mean": 1e-4}},
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=PARSeqCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='LiteRT-LM export supports.*tokenizers',
         )
diff --git a/keras_hub/src/models/qwen/qwen_causal_lm_test.py b/keras_hub/src/models/qwen/qwen_causal_lm_test.py
@@ -125,7 +125,8 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         # Use a preprocessor with sequence_length >= prefill_seq_len so the
         # unsupported-tokenizer error is reached before cache-length checks.
         preprocessor = QwenCausalLMPreprocessor(
@@ -138,7 +139,6 @@ def test_litertlm_export_unsupported(self):
             cls=QwenCausalLM,
             init_kwargs=init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex="Cannot infer HuggingFace tokenizer family.*Supported families",
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/qwen3_5/qwen3_5_causal_lm_test.py b/keras_hub/src/models/qwen3_5/qwen3_5_causal_lm_test.py
@@ -128,7 +128,8 @@ def test_saved_model(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         # Use a preprocessor with sequence_length >= prefill_seq_len so the
         # unsupported-tokenizer error is reached before cache-length checks.
         preprocessor = Qwen3_5CausalLMPreprocessor(
@@ -141,7 +142,6 @@ def test_litertlm_export_unsupported(self):
             cls=Qwen3_5CausalLM,
             init_kwargs=init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex="Cannot infer HuggingFace tokenizer family.*Supported families",
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/qwen3_moe/qwen3_moe_causal_lm_test.py b/keras_hub/src/models/qwen3_moe/qwen3_moe_causal_lm_test.py
@@ -1,8 +1,5 @@
-import os
 from unittest.mock import patch
 
-os.environ["KERAS_BACKEND"] = "torch"
-
 import pytest
 from keras import ops
 
@@ -131,12 +128,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=Qwen3MoeCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/qwen_moe/qwen_moe_causal_lm_test.py b/keras_hub/src/models/qwen_moe/qwen_moe_causal_lm_test.py
@@ -1,9 +1,5 @@
-import os
 from unittest.mock import patch
 
-if "KERAS_BACKEND" not in os.environ:
-    os.environ["KERAS_BACKEND"] = "jax"
-
 import keras
 import pytest
 from keras import ops
@@ -151,12 +147,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=QwenMoeCausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/models/rwkv7/rwkv7_causal_lm_test.py b/keras_hub/src/models/rwkv7/rwkv7_causal_lm_test.py
@@ -1,6 +1,7 @@
 import os
 from unittest.mock import patch
 
+import pytest
 from keras import ops
 
 from keras_hub.src.models.rwkv7.rwkv7_backbone import RWKV7Backbone
@@ -119,7 +120,8 @@ def wrapper(*args, **kwargs):
             except_output = [t + " " for t in prompt]
             self.assertEqual(except_output, output)
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         """
         Test that exporting a tiny RWKV7 model to LiteRT-LM raises a
         tokenizer-related ValueError, since RWKV7 tokenizers are not
@@ -129,5 +131,4 @@ def test_litertlm_export_unsupported(self):
             cls=RWKV7CausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='LiteRT-LM export supports.*tokenizers',
         )
diff --git a/keras_hub/src/models/smollm3/smollm3_causal_lm_test.py b/keras_hub/src/models/smollm3/smollm3_causal_lm_test.py
@@ -138,12 +138,12 @@ def test_litert_export(self):
             input_data=self.input_data,
         )
 
-    def test_litertlm_export_unsupported(self):
+    @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")
+    def test_litertlm_export_unsupported_tokenizer(self):
         self.run_litertlm_export_test(
             cls=SmolLM3CausalLM,
             init_kwargs=self.init_kwargs,
             prefill_seq_len=8,
-            expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',
         )
 
     @pytest.mark.extra_large
diff --git a/keras_hub/src/tests/test_case.py b/keras_hub/src/tests/test_case.py
@@ -1075,7 +1075,6 @@ def run_litertlm_export_test(
         generation_max_tokens=8,
         atol=1e-4,
         rtol=1e-4,
-        expected_error_regex=None,
         **export_kwargs,
     ):
         """Export a KerasHub model to LiteRT-LM and verify the bundle.
@@ -1103,38 +1102,13 @@ def run_litertlm_export_test(
                 test.
             atol: Absolute tolerance for numeric parity.
             rtol: Relative tolerance for numeric parity.
-            expected_error_regex: If provided, the test asserts that
-                ``model.export(..., format="litertlm", ...)`` raises a
-                ``ValueError`` whose message matches this regex. This
-                centralizes unsupported-tokenizer tests and exits before
-                requiring ``litert-torch`` or the PyTorch backend.
             **export_kwargs: Additional arguments forwarded to
                 ``model.export(..., format="litertlm", ...)``.
         """
 
         def _debug_print(msg):
             print(msg)
 
-        # Centralized unsupported-tokenizer assertion path. Tokenizer
-        # validation in export.py runs before backend/dependency checks, so
-        # this path works on any backend and without litert-torch installed.
-        if expected_error_regex is not None:
-            if model is None:
-                if cls is None or init_kwargs is None:
-                    raise ValueError(
-                        "Either `model` or both `cls` and `init_kwargs` must "
-                        "be provided."
-                    )
-                model = cls(**init_kwargs)
-            path = os.path.join(self.get_temp_dir(), "model.litertlm")
-            if prefill_seq_len is not None:
-                export_kwargs.setdefault("prefill_seq_len", prefill_seq_len)
-            with self.assertRaisesRegex(
-                ValueError, expected_error_regex
-            ):
-                model.export(path, format="litertlm", **export_kwargs)
-            return
-
         if keras.config.backend() != "torch":
             self.skipTest("LiteRT-LM export requires the PyTorch backend.")
 

Original file line number	Diff line number	Diff line change
`@@ -176,12 +176,12 @@ def test_litert_export(self):`
`176`	`176`	`input_data=self.input_data,`
`177`	`177`	`)`
`178`	`178`
`179`		`- def test_litertlm_export_unsupported(self):`
	`179`	`+ @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")`
	`180`	`+ def test_litertlm_export_unsupported_tokenizer(self):`
`180`	`181`	`self.run_litertlm_export_test(`
`181`	`182`	`cls=BloomCausalLM,`
`182`	`183`	`init_kwargs=self.init_kwargs,`
`183`	`184`	`prefill_seq_len=8,`
`184`		`- expected_error_regex='Cannot infer HuggingFace tokenizer family.*Supported families',`
`185`	`185`	`)`
`186`	`186`
`187`	`187`	`@pytest.mark.extra_large`
Original file line number	Diff line number	Diff line change
`@@ -124,11 +124,11 @@ def test_litert_export(self):`
`124`	`124`	`}, # More lenient thresholds for numerical differences`
`125`	`125`	`)`
`126`	`126`
`127`		`- def test_litertlm_export_unsupported(self):`
	`127`	`+ @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")`
	`128`	`+ def test_litertlm_export_unsupported_tokenizer(self):`
`128`	`129`	`"""GPT-NeoX tokenizer is not a supported LiteRT-LM family."""`
`129`	`130`	`self.run_litertlm_export_test(`
`130`	`131`	`cls=GPTNeoXCausalLM,`
`131`	`132`	`init_kwargs=self.init_kwargs,`
`132`	`133`	`prefill_seq_len=8,`
`133`		`- expected_error_regex="Cannot infer HuggingFace tokenizer family\|Supported families are 'gpt2', 'llama3', and 'qwen3'",`
`134`	`134`	`)`
Original file line number	Diff line number	Diff line change
`@@ -121,12 +121,12 @@ def test_litert_export(self):`
`121`	`121`	`input_data=self.input_data,`
`122`	`122`	`)`
`123`	`123`
`124`		`- def test_litertlm_export_unsupported(self):`
	`124`	`+ @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")`
	`125`	`+ def test_litertlm_export_unsupported_tokenizer(self):`
`125`	`126`	`self.run_litertlm_export_test(`
`126`	`127`	`cls=GptOssCausalLM,`
`127`	`128`	`init_kwargs=self.init_kwargs,`
`128`	`129`	`prefill_seq_len=8,`
`129`		`- expected_error_regex='Cannot infer HuggingFace tokenizer family',`
`130`	`130`	`)`
`131`	`131`
`132`	`132`	`@pytest.mark.extra_large`
Original file line number	Diff line number	Diff line change
`@@ -130,10 +130,10 @@ def test_litert_export(self):`
`130`	`130`	`output_thresholds={"*": {"max": 1e-3, "mean": 1e-4}},`
`131`	`131`	`)`
`132`	`132`
`133`		`- def test_litertlm_export_unsupported(self):`
	`133`	`+ @pytest.mark.xfail(reason="Tokenizer not supported for LiteRT-LM export")`
	`134`	`+ def test_litertlm_export_unsupported_tokenizer(self):`
`134`	`135`	`self.run_litertlm_export_test(`
`135`	`136`	`cls=PARSeqCausalLM,`
`136`	`137`	`init_kwargs=self.init_kwargs,`
`137`	`138`	`prefill_seq_len=8,`
`138`		`- expected_error_regex='LiteRT-LM export supports.*tokenizers',`
`139`	`139`	`)`