@ngocsangairvds/vsaf 3.2.14 → 3.2.15

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_profile_aware_row_timeout.py

@@ -1,102 +0,0 @@
-"""Tests for FR-272: Profile-aware row timeout defaults (TSK-940.42).
-
-Tests cover:
-- Default row_timeout_ms is 60000 for agentic profiles (auto, on)
-- Default row_timeout_ms is 45000 for prompt-only profiles (off)
-- Explicit CLI value overrides profile default
-- Adaptive extension system (120s ceiling) unaffected
-"""
-
-from __future__ import annotations
-
-import pytest
-
-
-def _resolve_row_timeout(
-    *,
-    row_timeout_ms: int | None,
-    agentic_mode: str,
-    env_row_timeout_ms: str | None = None,
-) -> int:
-    """Replicate the FR-272 resolution logic from workflow_cmds.py."""
-    if row_timeout_ms is None:
-        if str(env_row_timeout_ms or "").strip():
-            row_timeout_ms = int(str(env_row_timeout_ms).strip())
-        elif agentic_mode in {"auto", "on"}:
-            row_timeout_ms = 60000
-        else:
-            row_timeout_ms = 45000
-    return row_timeout_ms
-
-
-class TestProfileAwareRowTimeout:
-    """FR-272: Row timeout defaults become profile-aware."""
-
-    def test_agentic_auto_defaults_to_60s(self) -> None:
-        """AC-272.1: Agentic 'auto' profile defaults to 60000ms."""
-        assert _resolve_row_timeout(row_timeout_ms=None, agentic_mode="auto") == 60000
-
-    def test_agentic_on_defaults_to_60s(self) -> None:
-        """AC-272.1: Agentic 'on' profile defaults to 60000ms."""
-        assert _resolve_row_timeout(row_timeout_ms=None, agentic_mode="on") == 60000
-
-    def test_prompt_only_off_defaults_to_45s(self) -> None:
-        """AC-272.2: Prompt-only 'off' profile retains 45000ms default."""
-        assert _resolve_row_timeout(row_timeout_ms=None, agentic_mode="off") == 45000
-
-    def test_explicit_value_overrides_profile(self) -> None:
-        """AC-272.3: Explicit --row-timeout-ms takes precedence over profile default."""
-        assert _resolve_row_timeout(row_timeout_ms=30000, agentic_mode="auto") == 30000
-        assert _resolve_row_timeout(row_timeout_ms=90000, agentic_mode="off") == 90000
-
-    def test_runtime_profile_env_timeout_overrides_agentic_default(self) -> None:
-        """Runtime profile timeout policy env should override mode default when CLI timeout is omitted."""
-        assert _resolve_row_timeout(row_timeout_ms=None, agentic_mode="auto", env_row_timeout_ms="180000") == 180000
-        assert _resolve_row_timeout(row_timeout_ms=None, agentic_mode="off", env_row_timeout_ms="90000") == 90000
-
-    def test_explicit_cli_timeout_overrides_runtime_profile_env(self) -> None:
-        """CLI timeout must remain highest precedence."""
-        assert (
-            _resolve_row_timeout(
-                row_timeout_ms=75000,
-                agentic_mode="auto",
-                env_row_timeout_ms="180000",
-            )
-            == 75000
-        )
-
-    def test_invalid_runtime_profile_env_timeout_raises(self) -> None:
-        """Non-integer env timeout must fail fast."""
-        with pytest.raises(ValueError):
-            _resolve_row_timeout(row_timeout_ms=None, agentic_mode="auto", env_row_timeout_ms="abc")
-
-    def test_explicit_45s_with_agentic_auto(self) -> None:
-        """Explicit 45s works even in agentic mode."""
-        assert _resolve_row_timeout(row_timeout_ms=45000, agentic_mode="auto") == 45000
-
-    def test_explicit_60s_with_prompt_only(self) -> None:
-        """Explicit 60s works even in prompt-only mode."""
-        assert _resolve_row_timeout(row_timeout_ms=60000, agentic_mode="off") == 60000
-
-
-class TestAdaptiveExtensionCompatibility:
-    """AC-272.4: Adaptive timeout extension system (up to 120s ceiling) still works."""
-
-    def test_agentic_default_within_extension_ceiling(self) -> None:
-        """60s default is well within the 120s (120000ms) adaptive extension ceiling."""
-        default = _resolve_row_timeout(row_timeout_ms=None, agentic_mode="auto")
-        assert default == 60000
-        assert default < 120000  # ceiling
-
-    def test_prompt_only_default_within_extension_ceiling(self) -> None:
-        """45s default is well within the 120s adaptive extension ceiling."""
-        default = _resolve_row_timeout(row_timeout_ms=None, agentic_mode="off")
-        assert default == 45000
-        assert default < 120000  # ceiling
-
-    def test_extension_ceiling_constant(self) -> None:
-        """The 120s ceiling (120000ms) is the documented maximum for adaptive extension."""
-        ADAPTIVE_EXTENSION_CEILING_MS = 120000
-        for mode in ("auto", "on", "off"):
-            default = _resolve_row_timeout(row_timeout_ms=None, agentic_mode=mode)
-            assert default < ADAPTIVE_EXTENSION_CEILING_MS

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_profile_timeout_stagger_p160cd.py

@@ -1,205 +0,0 @@
-"""TSK-160.17 / TSK-160.21: Per-profile timeout + submission stagger tests.
-
-Covers:
-- _load_profile_timeouts YAML parsing and env var override (TSK-160.14)
-- _resolve_profile_timeout lookup chain (TSK-160.15)
-- Profile-specific timeout overrides global default (TSK-160.17)
-- _fill_capacity stagger applied only on multi-slot fill (TSK-160.21)
-"""
-
-from __future__ import annotations
-
-from pathlib import Path
-from typing import TYPE_CHECKING, Any
-
-from vds_audit_orchestrator.workflow_cmds import (
-    _load_profile_timeouts,
-    _resolve_profile_timeout,
-)
-
-if TYPE_CHECKING:
-    import pytest
-
-# ── TSK-160.17: Profile-specific timeout overrides global default ─────
-
-
-class TestLoadProfileTimeouts:
-    """Tests for _load_profile_timeouts config loader."""
-
-    def test_no_yaml_file_returns_global_default(self, tmp_path: Path) -> None:
-        """When YAML file does not exist, falls back to package config (P160 adds omniroute profiles)."""
-        result = _load_profile_timeouts(
-            yaml_path=tmp_path / "nonexistent.yaml",
-            global_default=1800,
-        )
-        assert result["__default__"] == 1800
-        assert result["omniroute-glm-openai"] == 900
-        assert result["omniroute-glm1-openai"] == 600
-
-    def test_yaml_default_overrides_global(self, tmp_path: Path) -> None:
-        """YAML defaults.timeout_seconds overrides the global_default param."""
-        yaml_file = tmp_path / "profile-timeouts.yaml"
-        yaml_file.write_text("defaults:\n  timeout_seconds: 2400\n")
-        result = _load_profile_timeouts(yaml_path=yaml_file, global_default=1800)
-        assert result["__default__"] == 2400
-
-    def test_yaml_profile_overrides(self, tmp_path: Path) -> None:
-        """YAML overrides section provides per-profile timeouts."""
-        yaml_file = tmp_path / "profile-timeouts.yaml"
-        yaml_file.write_text(
-            "defaults:\n  timeout_seconds: 1800\n"
-            "overrides:\n"
-            "  omniroute-glm1-openai: 600\n"
-            "  omniroute-glm-openai: 900\n"
-        )
-        result = _load_profile_timeouts(yaml_path=yaml_file, global_default=1800)
-        assert result["__default__"] == 1800
-        assert result["omniroute-glm1-openai"] == 600
-        assert result["omniroute-glm-openai"] == 900
-
-    def test_env_var_overrides_yaml(self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> None:
-        """Env var VDS_AUDIT_PROFILE_TIMEOUT_* overrides YAML override."""
-        yaml_file = tmp_path / "profile-timeouts.yaml"
-        yaml_file.write_text("defaults:\n  timeout_seconds: 1800\noverrides:\n  omniroute-glm1-openai: 600\n")
-        monkeypatch.setenv("VDS_AUDIT_PROFILE_TIMEOUT_OMNIROUTE_GLM1_OPENAI", "300")
-        result = _load_profile_timeouts(yaml_path=yaml_file, global_default=1800)
-        # Env var wins: 300 overrides YAML 600
-        assert result["omniroute-glm1-openai"] == 300
-
-    def test_env_var_with_hyphens_converted(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-        """Env key underscores are converted to hyphens for profile lookup."""
-        monkeypatch.setenv("VDS_AUDIT_PROFILE_TIMEOUT_MY_CUSTOM_PROFILE", "999")
-        result = _load_profile_timeouts(yaml_path=tmp_path / "missing.yaml", global_default=1800)
-        assert result["my-custom-profile"] == 999
-
-    def test_invalid_env_var_value_skipped(self, monkeypatch: pytest.MonkeyPatch, tmp_path: Path) -> None:
-        """Non-integer env var values are skipped with a warning."""
-        monkeypatch.setenv("VDS_AUDIT_PROFILE_TIMEOUT_BAD_PROFILE", "not-a-number")
-        result = _load_profile_timeouts(yaml_path=tmp_path / "missing.yaml", global_default=1800)
-        assert "bad-profile" not in result
-
-    def test_malformed_yaml_falls_back_to_global(self, tmp_path: Path) -> None:
-        """Malformed YAML file is handled gracefully."""
-        yaml_file = tmp_path / "profile-timeouts.yaml"
-        yaml_file.write_text("{{invalid yaml")
-        result = _load_profile_timeouts(yaml_path=yaml_file, global_default=1800)
-        assert result == {"__default__": 1800}
-
-    def test_empty_yaml_file(self, tmp_path: Path) -> None:
-        """Empty YAML file returns global default."""
-        yaml_file = tmp_path / "profile-timeouts.yaml"
-        yaml_file.write_text("")
-        result = _load_profile_timeouts(yaml_path=yaml_file, global_default=1800)
-        assert result == {"__default__": 1800}
-
-
-class TestResolveProfileTimeout:
-    """Tests for _resolve_profile_timeout lookup."""
-
-    def test_specific_profile_found(self) -> None:
-        timeouts = {"__default__": 1800, "fast-profile": 600}
-        assert _resolve_profile_timeout("fast-profile", timeouts) == 600
-
-    def test_unknown_profile_falls_back_to_default(self) -> None:
-        timeouts = {"__default__": 1800, "fast-profile": 600}
-        assert _resolve_profile_timeout("unknown-profile", timeouts) == 1800
-
-    def test_missing_default_uses_hardcoded_1800(self) -> None:
-        """If __default__ key somehow missing, fallback is 1800."""
-        assert _resolve_profile_timeout("any-profile", {}) == 1800
-
-    def test_profile_specific_overrides_global(self) -> None:
-        """TSK-160.17: The core assertion — profile timeout beats global."""
-        global_default = 1800
-        timeouts = _load_profile_timeouts(
-            yaml_path=Path("/nonexistent"),
-            global_default=global_default,
-        )
-        # Add a profile override
-        timeouts["fast-glm"] = 600
-        resolved = _resolve_profile_timeout("fast-glm", timeouts)
-        assert resolved == 600
-        assert resolved != global_default
-
-
-# ── TSK-160.21: Stagger applied only on multi-slot fill ───────────────
-
-
-class TestFillCapacityStagger:
-    """Tests for submission stagger in _fill_capacity."""
-
-    def _run_fill_capacity(
-        self,
-        *,
-        pending_count: int,
-        max_concurrent: int,
-        submission_stagger_ms: int,
-    ) -> tuple[list[dict[str, Any]], float]:
-        """Simulate _fill_capacity logic and return submitted jobs + elapsed time."""
-        import time as _time
-
-        pending_jobs: list[dict[str, Any]] = [
-            {"profile": f"p{i}", "repo_path": Path(f"/repo{i}")} for i in range(pending_count)
-        ]
-        submitted: list[dict[str, Any]] = []
-        active_count = 0
-
-        start = _time.monotonic()
-        submitted_this_fill = 0
-        while pending_jobs and active_count < max_concurrent:
-            if submitted_this_fill >= 1 and submission_stagger_ms > 0:
-                _time.sleep(submission_stagger_ms / 1000.0)
-            job = pending_jobs.pop(0)
-            submitted.append(job)
-            active_count += 1
-            submitted_this_fill += 1
-        elapsed = _time.monotonic() - start
-
-        return submitted, elapsed
-
-    def test_single_slot_no_stagger(self) -> None:
-        """Single-slot fill should NOT sleep (common FIRST_COMPLETED case)."""
-        submitted, elapsed = self._run_fill_capacity(
-            pending_count=1,
-            max_concurrent=4,
-            submission_stagger_ms=200,
-        )
-        assert len(submitted) == 1
-        # Should be nearly instant (no sleep)
-        assert elapsed < 0.05
-
-    def test_multi_slot_stagger_applied(self) -> None:
-        """Multi-slot fill should sleep between submissions."""
-        stagger_ms = 100
-        submitted, elapsed = self._run_fill_capacity(
-            pending_count=3,
-            max_concurrent=3,
-            submission_stagger_ms=stagger_ms,
-        )
-        assert len(submitted) == 3
-        # 2 sleeps of 100ms each = ~200ms minimum
-        expected_min = (len(submitted) - 1) * stagger_ms / 1000.0
-        assert elapsed >= expected_min * 0.8  # Allow 20% tolerance
-
-    def test_stagger_zero_disables_sleep(self) -> None:
-        """stagger_ms=0 should not sleep even on multi-slot fill."""
-        submitted, elapsed = self._run_fill_capacity(
-            pending_count=3,
-            max_concurrent=3,
-            submission_stagger_ms=0,
-        )
-        assert len(submitted) == 3
-        assert elapsed < 0.05
-
-    def test_two_slot_fill_has_one_stagger(self) -> None:
-        """Filling exactly 2 slots should have exactly 1 stagger delay."""
-        stagger_ms = 100
-        submitted, elapsed = self._run_fill_capacity(
-            pending_count=2,
-            max_concurrent=2,
-            submission_stagger_ms=stagger_ms,
-        )
-        assert len(submitted) == 2
-        # Exactly 1 sleep of 100ms
-        assert elapsed >= 0.08  # Allow tolerance
-        assert elapsed < 0.25  # But not too much (only 1 sleep)

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_progress_summary_phase169.py

@@ -1,96 +0,0 @@
-"""Phase 169 (P169-D, TSK-169.6): Tests for periodic dispatch progress summary gate.
-
-Verifies the gate invariants (50 completions OR 300 seconds) without instantiating
-the full dispatch loop. The gate logic is inline in workflow_cmds.py; these tests
-document and verify the threshold contracts independently.
-
-Gate rule:
-    emit = (completed - last_count) >= 50 OR (now_mono - last_time) >= 300
-"""
-
-from __future__ import annotations
-
-# ── Gate threshold constants (copied from workflow_cmds.py inline values) ──────
-_COMPLETION_GATE = 50
-_SECONDS_GATE = 300.0
-
-
-def _gate(completed: int, last_count: int, elapsed: float, last_elapsed: float) -> bool:
-    """Mirror of the inline gate condition from workflow_cmds.py."""
-    return (completed - last_count) >= _COMPLETION_GATE or (elapsed - last_elapsed) >= _SECONDS_GATE
-
-
-# ── Completion-count gate ─────────────────────────────────────────────────────
-
-
-def test_progress_gate_does_not_fire_before_50_completions() -> None:
-    """Gate must not fire before the 49th completion since last emit."""
-    for delta in range(1, _COMPLETION_GATE):
-        assert not _gate(delta, 0, 0.0, 0.0), f"Gate fired early at delta={delta}"
-
-
-def test_progress_gate_fires_at_exactly_50_completions() -> None:
-    """Gate must fire when exactly 50 completions have occurred since last emit."""
-    assert _gate(_COMPLETION_GATE, 0, 0.0, 0.0)
-
-
-def test_progress_gate_fires_at_50_completion_multiples() -> None:
-    """Gate fires at each additional 50-completion boundary."""
-    for n in range(1, 5):
-        completed = n * _COMPLETION_GATE
-        last_count = (n - 1) * _COMPLETION_GATE
-        assert _gate(completed, last_count, 0.0, 0.0), f"Gate did not fire at multiple {n}"
-
-
-def test_progress_gate_resets_count_prevents_double_fire() -> None:
-    """After the gate fires and resets, one more completion should NOT re-trigger."""
-    # Simulate: gate fired at completed=50, last_count is reset to 50.
-    completed_after_reset = _COMPLETION_GATE + 1
-    last_count_after_reset = _COMPLETION_GATE
-    # Only 1 new completion — should not re-trigger yet.
-    assert not _gate(completed_after_reset, last_count_after_reset, 0.0, 0.0)
-
-
-# ── Time gate ─────────────────────────────────────────────────────────────────
-
-
-def test_progress_gate_does_not_fire_before_300_seconds() -> None:
-    """Gate must not fire before 300 seconds have elapsed since last emit."""
-    for elapsed in [0.0, 100.0, 299.0, 299.9]:
-        assert not _gate(0, 0, elapsed, 0.0), f"Gate fired early at elapsed={elapsed}s"
-
-
-def test_progress_gate_fires_at_300_seconds() -> None:
-    """Gate must fire when exactly 300 seconds have elapsed since last emit."""
-    assert _gate(0, 0, _SECONDS_GATE, 0.0)
-
-
-def test_progress_gate_fires_after_300_seconds() -> None:
-    """Gate fires when elapsed time exceeds 300 seconds, regardless of completions."""
-    assert _gate(0, 0, 301.5, 0.0)
-
-
-def test_progress_gate_time_resets_prevents_double_fire() -> None:
-    """After the gate fires on time and resets, 1 extra second should NOT re-trigger."""
-    # Simulate: gate fired at now=300, last_time reset to 300.
-    now_after_reset = _SECONDS_GATE + 1.0
-    last_time_after_reset = _SECONDS_GATE
-    assert not _gate(0, 0, now_after_reset, last_time_after_reset)
-
-
-# ── OR semantics ──────────────────────────────────────────────────────────────
-
-
-def test_progress_gate_fires_when_either_condition_true() -> None:
-    """Gate fires when either condition is true — OR semantics."""
-    # Count only: enough completions, not enough time
-    assert _gate(_COMPLETION_GATE, 0, 100.0, 0.0)
-    # Time only: enough time, not enough completions
-    assert _gate(10, 0, _SECONDS_GATE, 0.0)
-    # Both: both conditions true
-    assert _gate(_COMPLETION_GATE, 0, _SECONDS_GATE, 0.0)
-
-
-def test_progress_gate_does_not_fire_when_neither_condition_true() -> None:
-    """Gate stays silent when neither threshold is reached."""
-    assert not _gate(49, 0, 299.9, 0.0)

package/tools/vds-scripts/audit_orchestrator/tests/unit/test_registry_checklist_diagnostics.py

@@ -1,124 +0,0 @@
-"""Tests for FR-269: Registry parse checklist discovery diagnostics (TSK-940.39)."""
-
-from __future__ import annotations
-
-from unittest.mock import AsyncMock
-
-import pytest
-from vds_audit_orchestrator.collectors.registry_parser import RegistryPageParser
-
-
-@pytest.fixture
-def parser() -> RegistryPageParser:
-    """Create a RegistryPageParser with no checklist override.
-
-    Uses a minimal MagicMock client (only client._timeout is read during __init__).
-    All test methods override _get_children, _page_id, and _page_url directly,
-    so no real client calls occur.
-    """
-    from unittest.mock import MagicMock
-
-    client = MagicMock()
-    client._timeout = 120
-    return RegistryPageParser(client)
-
-
-def _make_page(page_id: str, title: str) -> dict[str, str]:
-    return {"id": page_id, "title": title}
-
-
-@pytest.mark.asyncio
-async def test_checklist_discovery_emits_warning_when_no_checklist_found(
-    parser: RegistryPageParser, capfd: pytest.CaptureFixture[str], caplog: pytest.LogCaptureFixture
-) -> None:
-    """AC-269.1/AC-269.2: Structured diagnostic warning when checklist discovery fails."""
-    pages = [
-        _make_page("100", "3.2 Hệ thống quản trị"),
-        _make_page("101", "Audit History"),
-        _make_page("102", "Some Random Page"),
-    ]
-    parser._get_children = AsyncMock(return_value=pages)  # type: ignore[assignment]
-    parser._page_id = staticmethod(lambda p: p.get("id"))  # type: ignore[assignment]
-    parser._page_url = staticmethod(lambda p, fallback_page_id="": f"/page/{fallback_page_id}")  # type: ignore[assignment]
-
-    projects_root, checklist_candidates = await parser._find_projects_root_and_checklist_deterministic("root-1")
-
-    assert checklist_candidates == []
-    assert projects_root is not None  # "3.2" matches PROJECT_CONTAINER
-
-    # FR-269 AC-269.3: warning is visible in default log output.
-    # structlog may write to stdout or stderr depending on configuration.
-    captured = capfd.readouterr()
-    combined = captured.out + captured.err + caplog.text
-    assert "checklist_discovery_failed" in combined
-    assert "checklist-page" in combined  # guidance text present
-
-
-@pytest.mark.asyncio
-async def test_checklist_discovery_no_warning_when_checklist_found(
-    parser: RegistryPageParser, capfd: pytest.CaptureFixture[str], caplog: pytest.LogCaptureFixture
-) -> None:
-    """No diagnostic warning when checklist IS discovered."""
-    pages = [
-        _make_page("200", "3.1 Checklist đánh giá"),
-        _make_page("201", "3.2 Hệ thống"),
-    ]
-    parser._get_children = AsyncMock(return_value=pages)  # type: ignore[assignment]
-    parser._page_id = staticmethod(lambda p: p.get("id"))  # type: ignore[assignment]
-    parser._page_url = staticmethod(lambda p, fallback_page_id="": f"/page/{fallback_page_id}")  # type: ignore[assignment]
-
-    _, checklist_candidates = await parser._find_projects_root_and_checklist_deterministic("root-2")
-
-    assert checklist_candidates
-    assert checklist_candidates[0]["id"] == "200"
-    assert checklist_candidates[0]["profile_id"] == "default"
-    # No warning should be emitted
-    captured = capfd.readouterr()
-    combined = captured.out + captured.err + caplog.text
-    assert "checklist_discovery_failed" not in combined
-
-
-@pytest.mark.asyncio
-async def test_checklist_discovery_no_warning_with_override(
-    parser: RegistryPageParser, capfd: pytest.CaptureFixture[str], caplog: pytest.LogCaptureFixture
-) -> None:
-    """No warning when explicit --checklist-page override is provided."""
-    parser.checklist_page_override = "999"
-    pages = [
-        _make_page("300", "Random page"),
-    ]
-    parser._get_children = AsyncMock(return_value=pages)  # type: ignore[assignment]
-    parser._page_id = staticmethod(lambda p: p.get("id"))  # type: ignore[assignment]
-    parser._page_url = staticmethod(lambda p, fallback_page_id="": f"/page/{fallback_page_id}")  # type: ignore[assignment]
-
-    _, checklist_candidates = await parser._find_projects_root_and_checklist_deterministic("root-3")
-
-    assert checklist_candidates
-    assert checklist_candidates[0]["id"] == "999"
-    assert checklist_candidates[0]["profile_id"] == "default"
-    captured = capfd.readouterr()
-    combined = captured.out + captured.err + caplog.text
-    assert "checklist_discovery_failed" not in combined
-
-
-@pytest.mark.asyncio
-async def test_checklist_discovery_warning_includes_child_pages(
-    parser: RegistryPageParser, capfd: pytest.CaptureFixture[str], caplog: pytest.LogCaptureFixture
-) -> None:
-    """AC-269.2: Diagnostic includes child pages found and searched patterns."""
-    pages = [
-        _make_page("400", "Audit History"),
-        _make_page("401", "Project Overview"),
-    ]
-    parser._get_children = AsyncMock(return_value=pages)  # type: ignore[assignment]
-    parser._page_id = staticmethod(lambda p: p.get("id"))  # type: ignore[assignment]
-    parser._page_url = staticmethod(lambda p, fallback_page_id="": f"/page/{fallback_page_id}")  # type: ignore[assignment]
-
-    await parser._find_projects_root_and_checklist_deterministic("root-4")
-
-    captured = capfd.readouterr()
-    combined = captured.out + captured.err + caplog.text
-    assert "checklist_discovery_failed" in combined
-    # Verify child pages are included in the diagnostic
-    assert "Audit History" in combined
-    assert "Project Overview" in combined