Intelligent Regression¶
Agents / Intelligent Regression answers one question: a change happened — which of my test cases does it affect, and why?
A change is a code diff, a new revision of a requirement, a document, a ticket, or a sentence somebody wrote down. Your assistant reads it, splits it into change points, searches your workspace for what each point reaches, and hands the result in. XPressRT checks that result before it accepts it, shows it here, and keeps what you decide beside it.
It is a static analysis: it never looks at which test ran when or how often something was red. Nothing in your test cases is changed by it — adapting stays your decision.
What the page shows¶
The page is read top to bottom. At the top the run: its title, its quality in colour (high, medium, low) with the reason it is not higher, what was compared, where the change and the requirements come from — each source with its name as a link and its scope, such as submodule cm7, branch main, see Where they come from — and three tiles — the test cases to adapt or decide, the changes without a test case, and how many test cases are affected. Each tile leads to its part of the page.
Under it Regression planning, always open: how much of your test base the change needs, in test cases and in runs, and Make a test plan. Then the parts of the page, each a card that folds, in the order you work through them:
| Part | What it answers | Starts |
|---|---|---|
| What changed | the facts, before anybody judges them | open |
| To adapt | test cases where something has to be adapted, decided or thought over | open |
| Run as it is | test cases the change affects that need nothing | folded |
| Changes without a test case | what nothing here checks | open |
| Hints | a loose relation, not counted | folded |
| Findings | where code and requirements disagree | open |
| Decision log | what people already decided about this run | open |
How you left a part folded or open is kept for you; a part with nothing in it starts folded. The run you chose is in the address, so a reload or a link keeps it. A test case stays in one place with all the points that hit it: under To adapt if any of them needs something, otherwise under Run as it is. The decision log is a record, not work: nothing in it is waiting for you.
The number at the top. How much of your test base this change needs: 21 of 44 test cases affected by the changes (48 %), and beside it the same count including variants, because at the bench a run is a row of the variants table, not a test case. XPressRT computes it from the run, your decisions and the pool — every test case counted once, with the strongest classification it has. Hints are not counted; they are named next to it, so leaving them out stays a visible decision.
The line under it: what is still open. 2 open: 1 adaptation(s) not in the
test case yet, 1 change(s) without a test case. — and when everything stands,
✓ Nothing open: every change is checked, adapted or decided. That is the state
of the run as a checklist, and the end state it works towards: everywhere
affected, action none, nothing open — because somebody fixed it, not because
somebody clicked it away.
An adaptation counts as done when it is in the test case, not when the agent reported it. The page reads the test case itself.
The warning at the top. N changes are covered by no test case — the changes where nothing in your workspace checks anything. That is the other half of the picture: the number above says what you save, this one says where you know nothing.
Change points. What changed, one statement each: where it stands, what it was before and what holds now, and where the "before" comes from — a source, a reading of the agent, or "not known". Cosmetic points (a blank line, a version string) are folded away; they never carry a finding.
To adapt and Run as it is, grouped by test case, direct hits first. An adaptation shows what it changes as a difference: the old line red, the new one green. Every entry carries its evidence — a judging step, a requirement tag, a coverage run, a data point, a static dependency, a functional relation — and the whole chain from the change to the test case is one click away. A test case without evidence cannot be here; it is a hint.
What the test case says now stands in the row of every adaptation, without opening the chain: ✓ step 3 now reads "Then between 2 s and 2.5 s the system is Ready" against step 3 still reads "Then within 2 s the system is Ready" — not changed yet. It is read from the test case, so it is right even when the agent changed the line and forgot to say so — and the waiting-for-the-agent note disappears the moment the value is there.
What is to be done is said as a sentence, with the short word beside it:
| Word | Means | What to do |
|---|---|---|
none |
affected, but nothing in the test case has to change | run it as it is |
adapt |
it checks the state before the change | approve or reject the proposal |
obsolete |
it checks something the change removed | rethink the test case |
decide |
code and requirement disagree | pick one of the two options |
An adapt says what kind of change it is, and each kind carries what tells
later whether it happened:
| Kind | What it proposes |
|---|---|
| replace a line | a value becomes another — "within 2 s" → "between 2 s and 2.5 s" in step 3 |
| remove a step | remove step 4 ("the lamp is green") — the change took away what it checked |
| remove rows | rows of the variants table, with their cells, because the numbers shift after the first deletion |
| add a step | a sentence that is missing. It has to exist as a step already: what is approved has to be something the agent can then write |
Hints are test cases with a loose relation — same device, same area — and no evidence. They stay apart on purpose, and they are not in a plan.
Changes without a test case, each with the search log: what was searched for, so that "nothing found" can be repeated.
Findings: what code and requirements disagree on, what is not specified, what the diff does not show, global changes, and where coverage is not reliable.
What you do here¶
Type your name under Deciding as first. XPressRT has no login: what you
decide is kept beside the run under that name and the time, in
agents/regression/runs/<run>/review.json. The Decisions section shows it,
and so do the HTML report and read_agent_run.
- Reclassify a test case when you know better — directly shown, functionally related, or hint only; Reclassify… on its row opens the choice. A reason is required, and the number at the top is recalculated. This is also the way a hint gets into a plan.
- Schedule regression — the button under the title, also on the empty page. Say what changed — firmware 2.4 → 2.5 (commits abc..def), SRS revision 7; without it there is no request, because the agent has to know what to check against. It lands in the Agent queue. The regression run your assistant hands in for it closes it; if it cannot do it — the change is not readable, a source is missing — it says why.
- Approve or reject an adaptation. An approval is not carried out by the
page: it becomes a request your agent sees the next time it calls
XPressRT, and the agent changes exactly that one line with
adapt_step. If the text is no longer in the test case, the page says so and offers Mark as done instead. - Withdraw approval — while the agent has not answered the request yet: with a reason, under your name. The request is withdrawn, the adaptation is up for decision again, and the card says who withdrew it and why. It is a line of its own in the decision log. The same button is in the Agent queue.
- Decide a contradiction: the two options stand side by side, and neither is preselected. Code is what is observed, the requirement is what is wanted.
- Ask for a missing test case where a change has none: the agent gets it as
a request, with the point and its search log. When it writes one, it names
it — and then the change moves up to the affected test cases with action
none, marked written for this change, on request, and drops out of "Changes without a test case". A name that points at nothing is refused: the request stays open instead. If the agent cannot write one — a data point is missing, a requirement is undecided — its reason stands here in place of the button, with who said it and when, and in the decision log. Asking again changes nothing until that is dealt with. - Start coverage for requirements whose coverage is not current. It runs as its own coverage run, limited to those requirements, and is linked here.
- Make a test plan from the affected test cases, without hints and without the obsolete ones, plus the suites your rules require for a global change. If something is still open, the plan can be made and the page says so: the plan can be made now; these test cases will change while it stands. The same count as in the header, and it is in the answer an agent gets too.
A request waits for an agent to call XPressRT — the page cannot reach it. Every
open request is named in one line above every answer the agent gets; the whole
of it — the finding, what was already searched, how to do it — is in
open_requests. If no agent is working, tell your assistant: Work through the
open requests in XPressRT. Everything that is waiting, from every page, is in
the Agent queue.
Whatever the agent answers, it is kept: done, or could not be done and why.
Quality, and why it is not chosen¶
Every run carries a quality — high, medium, low — computed from what went in: a diff, confirmed points, requirements, current coverage. A run that claims more than its input carries is refused, and the page says why it is not higher.
Rules for global changes¶
A compiler, a toolchain, an RTOS or a hardware revision is not searched test by test. Here you say which suites such a change requires; every run then names them for its global points, and a plan takes them along. The rules belong to the workspace and are kept by a person, not by the agent.
What it deliberately does not do¶
No run history, no pass rates, no bench minutes, no code coverage. Whether a test case ever ran says nothing about whether this change reaches it — and minutes come from a plan, not from an analysis.