@tduncan / Nvidia-Optimization-Stack-VLLM Mirror · read-only / commits / 2c3c1bd07a
Fork 0

A high-throughput and memory-efficient inference and serving engine for LLMs

Mirrored from https://github.com/tduncan-lum/Nvidia-Optimization-Stack---VLLM.git

Synced Nov 14, 05:30 UTC

[V0 Deprecation] Remove V0 Engine tests (#25114)

Signed-off-by: Woosuk Kwon <woosuk.kwon@berkeley.edu>

Woosuk Kwon committed Sep 17, 2025 at 19:38 UTC 2c3c1bd07aad253a34c97563bc5d466adaecaa18
7 files changed +1 -622
tests/engine/conftest.py deleted
-12
@@ -1,12 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -import pytest
4 -
5 -
6 -@pytest.fixture(scope="function", autouse=True)
7 -def use_v0_only(monkeypatch):
8 - """
9 - Since this module is V0 only, set VLLM_USE_V1=0 for
10 - all tests in the module.
11 - """
12 - monkeypatch.setenv('VLLM_USE_V1', '0')
tests/engine/test_computed_prefix_blocks.py deleted
-37
@@ -1,37 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -
4 -import pytest
5 -
6 -from vllm.engine.arg_utils import EngineArgs
7 -from vllm.engine.llm_engine import LLMEngine
8 -from vllm.sampling_params import SamplingParams
9 -
10 -
11 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
12 -@pytest.mark.parametrize("block_size", [16])
13 -def test_computed_prefix_blocks(model: str, block_size: int):
14 - # This test checks if we are able to run the engine to completion
15 - # without triggering asserts.
16 - # We are in a scenario where all blocks from the second request's prompt
17 - # are full and already computed when the second request arrives.
18 - prompt = (
19 - "You are a helpful assistant. How do I build a car from cardboard and "
20 - "paper clips? Is there an easy to follow video tutorial available "
21 - "online for free?")
22 - prompt2 = (
23 - " Please recommend to me some resources where I can learn not only to "
24 - "handle technical difficulties of building a car, but also "
25 - "decoration.")
26 -
27 - engine_args = EngineArgs(model=model,
28 - block_size=block_size,
29 - enable_prefix_caching=True)
30 -
31 - engine = LLMEngine.from_engine_args(engine_args)
32 - sampling_params = SamplingParams()
33 -
34 - engine.add_request("0", prompt + prompt2, sampling_params)
35 - engine.step()
36 - engine.add_request("1", prompt, sampling_params)
37 - engine.step()
tests/engine/test_executor.py deleted
-111
@@ -1,111 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -
4 -import asyncio
5 -import os
6 -from typing import Any, Callable, Optional, Union
7 -
8 -import pytest
9 -
10 -from vllm.engine.arg_utils import AsyncEngineArgs, EngineArgs
11 -from vllm.engine.async_llm_engine import AsyncLLMEngine
12 -from vllm.engine.llm_engine import LLMEngine
13 -from vllm.executor.uniproc_executor import UniProcExecutor
14 -from vllm.sampling_params import SamplingParams
15 -
16 -
17 -class Mock:
18 - ...
19 -
20 -
21 -class CustomUniExecutor(UniProcExecutor):
22 -
23 - def collective_rpc(self,
24 - method: Union[str, Callable],
25 - timeout: Optional[float] = None,
26 - args: tuple = (),
27 - kwargs: Optional[dict] = None) -> list[Any]:
28 - # Drop marker to show that this was run
29 - with open(".marker", "w"):
30 - ...
31 - return super().collective_rpc(method, timeout, args, kwargs)
32 -
33 -
34 -CustomUniExecutorAsync = CustomUniExecutor
35 -
36 -
37 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
38 -def test_custom_executor_type_checking(model):
39 - with pytest.raises(ValueError):
40 - engine_args = EngineArgs(model=model,
41 - distributed_executor_backend=Mock)
42 - LLMEngine.from_engine_args(engine_args)
43 - with pytest.raises(ValueError):
44 - engine_args = AsyncEngineArgs(model=model,
45 - distributed_executor_backend=Mock)
46 - AsyncLLMEngine.from_engine_args(engine_args)
47 -
48 -
49 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
50 -def test_custom_executor(model, tmp_path):
51 - cwd = os.path.abspath(".")
52 - os.chdir(tmp_path)
53 - try:
54 - assert not os.path.exists(".marker")
55 -
56 - engine_args = EngineArgs(
57 - model=model,
58 - distributed_executor_backend=CustomUniExecutor,
59 - enforce_eager=True, # reduce test time
60 - )
61 - engine = LLMEngine.from_engine_args(engine_args)
62 - sampling_params = SamplingParams(max_tokens=1)
63 -
64 - engine.add_request("0", "foo", sampling_params)
65 - engine.step()
66 -
67 - assert os.path.exists(".marker")
68 - finally:
69 - os.chdir(cwd)
70 -
71 -
72 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
73 -def test_custom_executor_async(model, tmp_path):
74 - cwd = os.path.abspath(".")
75 - os.chdir(tmp_path)
76 - try:
77 - assert not os.path.exists(".marker")
78 -
79 - engine_args = AsyncEngineArgs(
80 - model=model,
81 - distributed_executor_backend=CustomUniExecutorAsync,
82 - enforce_eager=True, # reduce test time
83 - )
84 - engine = AsyncLLMEngine.from_engine_args(engine_args)
85 - sampling_params = SamplingParams(max_tokens=1)
86 -
87 - async def t():
88 - stream = await engine.add_request("0", "foo", sampling_params)
89 - async for x in stream:
90 - ...
91 -
92 - asyncio.run(t())
93 -
94 - assert os.path.exists(".marker")
95 - finally:
96 - os.chdir(cwd)
97 -
98 -
99 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
100 -def test_respect_ray(model):
101 - # even for TP=1 and PP=1,
102 - # if users specify ray, we should use ray.
103 - # users might do this if they want to manage the
104 - # resources using ray.
105 - engine_args = EngineArgs(
106 - model=model,
107 - distributed_executor_backend="ray",
108 - enforce_eager=True, # reduce test time
109 - )
110 - engine = LLMEngine.from_engine_args(engine_args)
111 - assert engine.model_executor.uses_ray
tests/engine/test_multiproc_workers.py deleted
-179
@@ -1,179 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -
4 -import asyncio
5 -from concurrent.futures import ThreadPoolExecutor
6 -from functools import partial
7 -from time import sleep
8 -from typing import Any
9 -
10 -import pytest
11 -
12 -from vllm.config import VllmConfig
13 -from vllm.executor.multiproc_worker_utils import (ProcessWorkerWrapper,
14 - ResultHandler, WorkerMonitor)
15 -from vllm.worker.worker_base import WorkerWrapperBase
16 -
17 -
18 -class DummyWorkerWrapper(WorkerWrapperBase):
19 - """Dummy version of vllm.worker.worker.Worker"""
20 -
21 - def worker_method(self, worker_input: Any) -> tuple[int, Any]:
22 - sleep(0.05)
23 -
24 - if isinstance(worker_input, Exception):
25 - # simulate error case
26 - raise worker_input
27 -
28 - return self.rpc_rank, input
29 -
30 -
31 -def _start_workers() -> tuple[list[ProcessWorkerWrapper], WorkerMonitor]:
32 - result_handler = ResultHandler()
33 - vllm_config = VllmConfig()
34 - workers = [
35 - ProcessWorkerWrapper(result_handler, DummyWorkerWrapper, vllm_config,
36 - rank) for rank in range(8)
37 - ]
38 -
39 - worker_monitor = WorkerMonitor(workers, result_handler)
40 - assert not worker_monitor.is_alive()
41 -
42 - result_handler.start()
43 - worker_monitor.start()
44 - assert worker_monitor.is_alive()
45 -
46 - return workers, worker_monitor
47 -
48 -
49 -def test_local_workers() -> None:
50 - """Test workers with sync task submission"""
51 -
52 - workers, worker_monitor = _start_workers()
53 -
54 - def execute_workers(worker_input: str) -> None:
55 - worker_outputs = [
56 - worker.execute_method("worker_method", worker_input)
57 - for worker in workers
58 - ]
59 -
60 - for rank, output in enumerate(worker_outputs):
61 - assert output.get() == (rank, input)
62 -
63 - executor = ThreadPoolExecutor(max_workers=4)
64 -
65 - # Test concurrent submission from different threads
66 - futures = [
67 - executor.submit(partial(execute_workers, f"thread {thread_num}"))
68 - for thread_num in range(4)
69 - ]
70 -
71 - for future in futures:
72 - future.result()
73 -
74 - # Test error case
75 - exception = ValueError("fake error")
76 - result = workers[0].execute_method("worker_method", exception)
77 - try:
78 - result.get()
79 - pytest.fail("task should have failed")
80 - except Exception as e:
81 - assert isinstance(e, ValueError)
82 - assert str(e) == "fake error"
83 -
84 - # Test cleanup when a worker fails
85 - assert worker_monitor.is_alive()
86 - workers[3].process.kill()
87 -
88 - # Other workers should get shut down here
89 - worker_monitor.join(20)
90 -
91 - # Ensure everything is stopped
92 - assert not worker_monitor.is_alive()
93 - assert all(not worker.process.is_alive() for worker in workers)
94 -
95 - # Further attempts to submit tasks should fail
96 - try:
97 - _result = workers[0].execute_method("worker_method", "test")
98 - pytest.fail("task should fail once workers have been shut down")
99 - except Exception as e:
100 - assert isinstance(e, ChildProcessError)
101 -
102 -
103 -def test_local_workers_clean_shutdown() -> None:
104 - """Test clean shutdown"""
105 -
106 - workers, worker_monitor = _start_workers()
107 -
108 - assert worker_monitor.is_alive()
109 - assert all(worker.process.is_alive() for worker in workers)
110 -
111 - # Clean shutdown
112 - worker_monitor.close()
113 -
114 - worker_monitor.join(20)
115 -
116 - # Ensure everything is stopped
117 - assert not worker_monitor.is_alive()
118 - assert all(not worker.process.is_alive() for worker in workers)
119 -
120 - # Further attempts to submit tasks should fail
121 - try:
122 - _result = workers[0].execute_method("worker_method", "test")
123 - pytest.fail("task should fail once workers have been shut down")
124 - except Exception as e:
125 - assert isinstance(e, ChildProcessError)
126 -
127 -
128 -@pytest.mark.asyncio
129 -async def test_local_workers_async() -> None:
130 - """Test local workers with async task submission"""
131 -
132 - workers, worker_monitor = _start_workers()
133 -
134 - async def execute_workers(worker_input: str) -> None:
135 - worker_coros = [
136 - worker.execute_method_async("worker_method", worker_input)
137 - for worker in workers
138 - ]
139 -
140 - results = await asyncio.gather(*worker_coros)
141 - for rank, result in enumerate(results):
142 - assert result == (rank, input)
143 -
144 - tasks = [
145 - asyncio.create_task(execute_workers(f"task {task_num}"))
146 - for task_num in range(4)
147 - ]
148 -
149 - for task in tasks:
150 - await task
151 -
152 - # Test error case
153 - exception = ValueError("fake error")
154 - try:
155 - _result = await workers[0].execute_method_async(
156 - "worker_method", exception)
157 - pytest.fail("task should have failed")
158 - except Exception as e:
159 - assert isinstance(e, ValueError)
160 - assert str(e) == "fake error"
161 -
162 - # Test cleanup when a worker fails
163 - assert worker_monitor.is_alive()
164 - workers[3].process.kill()
165 -
166 - # Other workers should get shut down here
167 - worker_monitor.join(20)
168 -
169 - # Ensure everything is stopped
170 - assert not worker_monitor.is_alive()
171 - assert all(not worker.process.is_alive() for worker in workers)
172 -
173 - # Further attempts to submit tasks should fail
174 - try:
175 - _result = await workers[0].execute_method_async(
176 - "worker_method", "test")
177 - pytest.fail("task should fail once workers have been shut down")
178 - except Exception as e:
179 - assert isinstance(e, ChildProcessError)
tests/engine/test_options.py deleted
-58
@@ -1,58 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -from contextlib import nullcontext
4 -
5 -import pytest
6 -
7 -from vllm.entrypoints.llm import LLM
8 -from vllm.sampling_params import SamplingParams
9 -
10 -
11 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
12 -def test_skip_tokenizer_initialization(model: str):
13 - # This test checks if the flag skip_tokenizer_init skips the initialization
14 - # of tokenizer and detokenizer. The generated output is expected to contain
15 - # token ids.
16 - llm = LLM(
17 - model=model,
18 - skip_tokenizer_init=True,
19 - enforce_eager=True,
20 - )
21 - sampling_params = SamplingParams(prompt_logprobs=True, detokenize=True)
22 -
23 - with pytest.raises(ValueError, match="cannot pass text prompts when"):
24 - llm.generate("abc", sampling_params)
25 -
26 - outputs = llm.generate({"prompt_token_ids": [1, 2, 3]},
27 - sampling_params=sampling_params)
28 - assert len(outputs) > 0
29 - completions = outputs[0].outputs
30 - assert len(completions) > 0
31 - assert completions[0].text == ""
32 - assert completions[0].token_ids
33 -
34 -
35 -@pytest.mark.parametrize("model", ["distilbert/distilgpt2"])
36 -@pytest.mark.parametrize("enable_prompt_embeds", [True, False])
37 -def test_enable_prompt_embeds(hf_runner, model: str,
38 - enable_prompt_embeds: bool):
39 - prompt = "abc"
40 -
41 - with hf_runner(model) as hf_model:
42 - token_ids = hf_model.tokenizer(prompt, return_tensors="pt").input_ids
43 - token_ids = token_ids.to(hf_model.model.device)
44 -
45 - embed_layer = hf_model.model.get_input_embeddings()
46 - prompt_embeds = embed_layer(token_ids).squeeze(0)
47 -
48 - ctx = (nullcontext() if enable_prompt_embeds else pytest.raises(
49 - ValueError, match="set `--enable-prompt-embeds`"))
50 -
51 - llm = LLM(
52 - model=model,
53 - enable_prompt_embeds=enable_prompt_embeds,
54 - enforce_eager=True,
55 - )
56 -
57 - with ctx:
58 - llm.generate({"prompt_embeds": prompt_embeds})
tests/engine/test_short_mm_context.py
+1
@@ -25,6 +25,7 @@ def test_context_length_too_short(vllm_runner, image_assets, model):
25 model,
26 max_model_len=128, # LLaVA has a feature size of 576
27 enforce_eager=True,
28 + load_format="dummy",
29 )
30
31 with vllm_model:
tests/engine/test_stop_checker.py deleted
-225
@@ -1,225 +0,0 @@
1 -# SPDX-License-Identifier: Apache-2.0
2 -# SPDX-FileCopyrightText: Copyright contributors to the vLLM project
3 -
4 -import pytest
5 -from transformers import AutoTokenizer
6 -
7 -from vllm.engine.output_processor.stop_checker import StopChecker
8 -from vllm.reasoning import ReasoningParser
9 -from vllm.sampling_params import SamplingParams
10 -from vllm.sequence import Sequence, SequenceStatus
11 -
12 -REASONING_MODEL_NAME = "deepseek-ai/DeepSeek-R1-Distill-Qwen-1.5B"
13 -
14 -
15 -class MockReasoningParser(ReasoningParser):
16 - """Mock reasoning parser for testing purposes."""
17 -
18 - def __init__(self,
19 - tokenizer: AutoTokenizer,
20 - reasoning_active: bool = False):
21 - super().__init__(tokenizer)
22 - self.reasoning_active = reasoning_active
23 -
24 - def is_reasoning_end(self, input_ids: list[int]) -> bool:
25 - return not self.reasoning_active
26 -
27 - def extract_content_ids(self, input_ids: list[int]) -> list[int]:
28 - return input_ids
29 -
30 -
31 -class MockSequence(Sequence):
32 - """Mock sequence for testing purposes."""
33 -
34 - def __init__(self, token_ids, output_text="test_output", eos_token_id=0):
35 - self.token_ids = token_ids
36 - self.output_text = output_text
37 - self.eos_token_id = eos_token_id
38 - self.status = SequenceStatus.RUNNING
39 - self.stop_reason = None
40 -
41 - def get_token_ids(self):
42 - return self.token_ids
43 -
44 - def get_last_token_id(self):
45 - return self.token_ids[-1] if self.token_ids else None
46 -
47 - def get_len(self):
48 - return len(self.token_ids)
49 -
50 - def get_output_len(self):
51 - return len(self.token_ids) - 1 # Simulating prompt + outputs
52 -
53 -
54 -@pytest.fixture
55 -def deepseek_r1_qwen_tokenizer():
56 - return AutoTokenizer.from_pretrained(REASONING_MODEL_NAME)
57 -
58 -
59 -@pytest.fixture
60 -def stop_checker():
61 - return StopChecker(max_model_len=10)
62 -
63 -
64 -@pytest.fixture
65 -def stop_checker_with_reasoner():
66 - reasoner = MockReasoningParser(deepseek_r1_qwen_tokenizer)
67 - return StopChecker(max_model_len=10, reasoner=reasoner)
68 -
69 -
70 -def test_eos_token_stopping(stop_checker):
71 - """Test sequence stopping when EOS token is encountered."""
72 - seq = MockSequence(token_ids=[1, 2, 0], eos_token_id=0)
73 - sampling_params = SamplingParams()
74 -
75 - stop_checker.maybe_stop_sequence(seq,
76 - new_char_count=1,
77 - sampling_params=sampling_params)
78 -
79 - assert seq.status == SequenceStatus.FINISHED_STOPPED
80 -
81 -
82 -def test_ignore_eos(stop_checker):
83 - """Test sequence continuing when EOS token is ignored."""
84 - seq = MockSequence(token_ids=[1, 2, 0], eos_token_id=0)
85 - sampling_params = SamplingParams(ignore_eos=True)
86 -
87 - stop_checker.maybe_stop_sequence(seq,
88 - new_char_count=1,
89 - sampling_params=sampling_params)
90 -
91 - assert seq.status == SequenceStatus.RUNNING
92 -
93 -
94 -def test_min_tokens(stop_checker):
95 - """Test min_tokens prevents early stopping."""
96 - seq = MockSequence(token_ids=[1, 2, 0], eos_token_id=0)
97 - sampling_params = SamplingParams(min_tokens=3)
98 -
99 - stop_checker.maybe_stop_sequence(seq,
100 - new_char_count=1,
101 - sampling_params=sampling_params)
102 -
103 - assert seq.status == SequenceStatus.RUNNING
104 -
105 -
106 -def test_stop_token_ids(stop_checker):
107 - """Test sequence stopping with custom stop token IDs."""
108 - seq = MockSequence(token_ids=[1, 2, 3], eos_token_id=0)
109 - sampling_params = SamplingParams(stop_token_ids=[3])
110 -
111 - stop_checker.maybe_stop_sequence(seq,
112 - new_char_count=1,
113 - sampling_params=sampling_params)
114 -
115 - assert seq.status == SequenceStatus.FINISHED_STOPPED
116 - assert seq.stop_reason == 3
117 -
118 -
119 -def test_stop_strings(stop_checker):
120 - """Test sequence stopping with stop strings."""
121 - seq = MockSequence(token_ids=[1, 2, 3],
122 - output_text="test output with STOP",
123 - eos_token_id=0)
124 - sampling_params = SamplingParams(stop=["STOP"])
125 -
126 - stop_checker.maybe_stop_sequence(seq,
127 - new_char_count=1,
128 - sampling_params=sampling_params)
129 -
130 - assert seq.status == SequenceStatus.FINISHED_STOPPED
131 - assert seq.stop_reason == "STOP"
132 - assert "STOP" not in seq.output_text # Default behavior removes stop string
133 -
134 -
135 -def test_include_stop_str_in_output(stop_checker):
136 - """Test keeping stop strings in output."""
137 - seq = MockSequence(token_ids=[1, 2, 3],
138 - output_text="test output with STOP",
139 - eos_token_id=0)
140 - sampling_params = SamplingParams(stop=["STOP"],
141 - include_stop_str_in_output=True)
142 -
143 - stop_checker.maybe_stop_sequence(seq,
144 - new_char_count=5,
145 - sampling_params=sampling_params)
146 -
147 - assert seq.status == SequenceStatus.FINISHED_STOPPED
148 - assert "STOP" in seq.output_text
149 -
150 -
151 -def test_max_tokens(stop_checker):
152 - """Test sequence stopping at max_tokens."""
153 - seq = MockSequence(token_ids=[1, 2, 3], eos_token_id=0)
154 - sampling_params = SamplingParams(max_tokens=2)
155 -
156 - stop_checker.maybe_stop_sequence(seq,
157 - new_char_count=1,
158 - sampling_params=sampling_params)
159 -
160 - assert seq.status == SequenceStatus.FINISHED_LENGTH_CAPPED
161 -
162 -
163 -def test_max_model_len(stop_checker):
164 - """Test sequence stopping at max_model_len."""
165 - seq = MockSequence(token_ids=list(range(11)),
166 - eos_token_id=0) # 11 tokens, max is 10
167 - sampling_params = SamplingParams()
168 -
169 - stop_checker.maybe_stop_sequence(seq,
170 - new_char_count=1,
171 - sampling_params=sampling_params)
172 -
173 - assert seq.status == SequenceStatus.FINISHED_LENGTH_CAPPED
174 -
175 -
176 -def test_reasoning_skip_stops(stop_checker_with_reasoner):
177 - """Test that stop tokens and strings are ignored during reasoning."""
178 - # Set reasoning_active to True to simulate being in reasoning mode
179 - stop_checker_with_reasoner.reasoner.reasoning_active = True
180 -
181 - # Test with stop token
182 - seq = MockSequence(token_ids=[1, 2, 3], eos_token_id=0)
183 - sampling_params = SamplingParams(stop_token_ids=[3])
184 -
185 - stop_checker_with_reasoner.maybe_stop_sequence(
186 - seq, new_char_count=1, sampling_params=sampling_params)
187 - assert seq.status == SequenceStatus.RUNNING
188 -
189 - # Test with stop string
190 - seq = MockSequence(token_ids=[1, 2, 3], output_text="test STOP")
191 - sampling_params = SamplingParams(stop=["STOP"])
192 -
193 - stop_checker_with_reasoner.maybe_stop_sequence(
194 - seq, new_char_count=4, sampling_params=sampling_params)
195 - assert seq.status == SequenceStatus.RUNNING
196 -
197 - # But EOS token still stops the sequence
198 - seq = MockSequence(token_ids=[1, 2, 0], eos_token_id=0)
199 - sampling_params = SamplingParams()
200 -
201 - stop_checker_with_reasoner.maybe_stop_sequence(
202 - seq, new_char_count=1, sampling_params=sampling_params)
203 - assert seq.status == SequenceStatus.FINISHED_STOPPED
204 -
205 -
206 -def test_reasoning_end_enables_stops(stop_checker_with_reasoner):
207 - """Test that stop tokens work after reasoning ends."""
208 - # Set reasoning_active to False to simulate being out of reasoning mode
209 - stop_checker_with_reasoner.reasoner.reasoning_active = False
210 -
211 - # Test with stop token
212 - seq = MockSequence(token_ids=[1, 2, 3], eos_token_id=0)
213 - sampling_params = SamplingParams(stop_token_ids=[3])
214 -
215 - stop_checker_with_reasoner.maybe_stop_sequence(
216 - seq, new_char_count=1, sampling_params=sampling_params)
217 - assert seq.status == SequenceStatus.FINISHED_STOPPED
218 -
219 - # Test with stop string
220 - seq = MockSequence(token_ids=[1, 2, 3], output_text="test STOP")
221 - sampling_params = SamplingParams(stop=["STOP"])
222 -
223 - stop_checker_with_reasoner.maybe_stop_sequence(
224 - seq, new_char_count=4, sampling_params=sampling_params)
225 - assert seq.status == SequenceStatus.FINISHED_STOPPED