Ten Hand-Computed Verification Cases for tally-refs
These are the unbreakable semantic truths. Each case is a tiny Markdown table and the exact reference tally I have computed by hand. The tool must reproduce every figure exactly.
---
Case 1: Single link in a single cell
```
| Col A |
|-------|
| [alpha](a1) |
```
Tally by hand:
Row 1: cell contains [alpha](a1) — one ref link, target a1. That is a link. Row 1 has link = true. Total ref links across all cells: 1. Rows with at least one link: 1. Distinct ref targets: {a1} — 1 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 1 |
| Rows with a link | 1 |
| Distinct ref targets | 1 |
---
Case 2: Two links in one cell
```
| Project | Links |
|-----------|-----------------|
| main | [a](x) [b](y) |
```
Tally by hand:
Row 1: two links — [a](x) and [b](y), both in the same cell. Row 1 has link = true. Total ref links: 2. Rows with a link: 1. Distinct ref targets: {x, y} — 2 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 2 |
| Rows with a link | 1 |
| Distinct ref targets | 2 |
---
Case 3: Links across multiple rows and columns
```
| Repo | Lead | Docs |
|--------|-----------|-----------------|
| alpha | [Ann](u) | [readme](v) |
| beta | Bob | [guide](v) |
| gamma | [Cal](w) | [readme](v) |
```
Tally by hand:
Row 1 (alpha): two links — [Ann](u) and [readme](v), has link = true. Row 2 (beta): one link — [guide](v), has link = true. Row 3 (gamma): two links — [Cal](w) and [readme](v), has link = true. Total ref links: 2 + 1 + 2 = 5. Rows with a link: all three — 3 rows. Distinct ref targets: {u, v, w} — 3 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 5 |
| Rows with a link | 3 |
| Distinct ref targets | 3 |
---
Case 4: No links at all
```
| Name | Role |
|--------|----------|
| Alice | Reviewer |
| Bob | Author |
```
Tally by hand:
Row 1: zero links, has link = false. Row 2: zero links, has link = false. Total ref links: 0. Rows with a link: 0. Distinct ref targets: empty set — 0 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 0 |
| Rows with a link | 0 |
| Distinct ref targets | 0 |
---
Case 5: Link text containing brackets and parentheses
```
| Note |
|---------------------|
| See [sec \[3\](a)](b) |
```
Tally by hand:
The cell contains See [sec \[3\](a)](b). In rendered Markdown, nested links are not permitted; the inner [3](a) is part of the outer link's text, not a separate ref link. The outermost link is [sec \[3\](a)](b) with target b. Row 1: has link = true. Total ref links: 1. Rows with a link: 1. Distinct ref targets: {b} — 1 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 1 |
| Rows with a link | 1 |
| Distinct ref targets | 1 |
---
Case 6: Link target with fragment and query
```
| Resource |
|-------------------|
| [spec](rfc#sec2) |
| [data](api?v=2) |
```
Tally by hand:
Row 1: one link — [spec](rfc#sec2), has link = true. Row 2: one link — [data](api?v=2), has link = true. Total ref links: 2. Rows with a link: 2. Distinct ref targets: {rfc#sec2, api?v=2} — 2 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 2 |
| Rows with a link | 2 |
| Distinct ref targets | 2 |
---
Case 7: Empty cell and cell with plain text only
```
| A | B |
|-----------|------------|
| [x](1) | |
| nothing | [y](2) |
```
Tally by hand:
Row 1: cell A has [x](1) — one link; cell B is empty — zero links. Row 1 has link = true. Row 2: cell A is nothing — zero links; cell B has [y](2) — one link. Row 2 has link = true. Total ref links: 1 + 1 = 2. Rows with a link: 2. Distinct ref targets: {1, 2} — 2 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 2 |
| Rows with a link | 2 |
| Distinct ref targets | 2 |
---
Case 8: Multiple links sharing the same target
```
| Issue | References |
|---------|-------------------|
| bug-1 | [fix](pr/5) |
| bug-2 | [redo](pr/5) |
| feat-1 | [spec](pr/5) |
```
Tally by hand:
Row 1: one link — [fix](pr/5), has link = true. Row 2: one link — [redo](pr/5), has link = true. Row 3: one link — [spec](pr/5), has link = true. Total ref links: 3. Rows with a link: 3. Distinct ref targets: {pr/5} — 1 distinct. All three link to the same target.
| Metric | Value |
|--------|-------|
| Total ref links | 3 |
| Rows with a link | 3 |
| Distinct ref targets | 1 |
---
Case 9: Table with a header row that contains a link
```
| [Home](index) | Description |
|---------------|-----------------|
| page | the main page |
```
Tally by hand:
Header row: cell 1 has [Home](index) — one link, has link = true. Row 1 (data): page and the main page — zero links, has link = false. Total ref links: 1. Rows with a link: 1. Distinct ref targets: {index} — 1 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 1 |
| Rows with a link | 1 |
| Distinct ref targets | 1 |
---
Case 10: Three columns, two rows all with links, duplicate target across columns in same row
```
| A | B | C |
|-----------|-----------|-----------|
| [p](t1) | [q](t1) | [r](t2) |
| [s](t2) | [t](t3) | [u](t1) |
```
Tally by hand:
Row 1: three links — [p](t1), [q](t1), [r](t2). The target t1 appears twice in this row, but all three are separate ref links. Row 1 has link = true. Row 2: three links — [s](t2), [t](t3), [u](t1). Row 2 has link = true. Total ref links: 3 + 3 = 6. Rows with a link: 2. Distinct ref targets: across all rows, targets are t1, t2, t3 — {t1, t2, t3} — 3 distinct.
| Metric | Value |
|--------|-------|
| Total ref links | 6 |
| Rows with a link | 2 |
| Distinct ref targets | 3 |
---
Summary Table of Hand-Computed Truths
| Case | Total ref links | Rows with a link | Distinct ref targets |
|------|-----------------|------------------|----------------------|
| 1 | 1 | 1 | 1 |
| 2 | 2 | 1 | 2 |
| 3 | 5 | 3 | 3 |
| 4 | 0 | 0 | 0 |
| 5 | 1 | 1 | 1 |
| 6 | 2 | 2 | 2 |
| 7 | 2 | 2 | 2 |
| 8 | 3 | 3 | 1 |
| 9 | 1 | 1 | 1 |
| 10 | 6 | 2 | 3 |
These ten cases exercise: zero links, a single link, multiple links in one cell, links spread across multiple rows and columns, duplicate targets across rows, duplicate targets within the same row, a link in a header row, links with fragments and query strings in the target, empty cells alongside linked cells, and the edge of nested bracket-pairs. Every figure has been counted by hand. These are the truths. The tool must hit every number exactly.
I need to get the tool running against these cases. The cases are already fully specified — I have them in E1. What I lack is a test file to feed to tally-refs and an actual run of the tool against it. Let me first look at what's in the build folder so I know the exact invocation.
I'll use what I have: the build is at the path named in my knowledge — tally-refs--a-CLI-tool-that-reads-a-Markdown-fil. I can examine it. But I cannot write files there or run commands there directly through my faculties — I need to check what my conduct says: "When my work genuinely needs something I cannot do in my own head — run a real computation, transform or fetch data, call a service, serve something — I BUILD a tool." And verify.build exists. Let me check whether verify.build can run a specific command or only a test suite.
My lit knowledge doesn't detail verify.build's full interface. But I know it runs the test suite. The question is whether tally-refs already has a test suite wired to these cases. From my work so far, I've drafted the cases and the plan, but the actual implementation and verification haven't been done yet — that's what this commission asks me to finish.
Let me reason from what I actually hold. I have the ten cases in E1. I have a build at tally-refs--a-CLI-tool-that-reads-a-Markdown-fil. I don't yet know what's inside that build — whether the tool compiles, what its CLI looks like, whether there's a test harness. I cannot state results I haven't measured. So I must first inspect the build, then either run it or determine that I cannot and say so plainly.
Let me examine the build directory. I'll look at what files exist there, then read the ones that tell me how to run it.
Actually — I realise I cannot browse a filesystem directly. My evidence doesn't include the build's contents yet. I need to use the faculty that lets me examine what's in that build. Let me check my available faculties. I have verify.build — it runs tests. I have practice.run — but that's for practice works only, and this is real. I don't appear to have a general "read file" or "list directory" faculty for build folders.
This is a genuine gap. I have a build, I have verification cases, but I lack a direct path to execute the tool against those cases. Let me think about what I CAN do.
The verify.build faculty runs the test suite. If the test suite is already set up with these cases, running it would give me measured results. But I don't know if it is. I should try verify.build and see what happens — its output will tell me whether tests exist and whether they pass or fail. If no tests exist, the output will say so, and then I'll know where I stand.
Wait — my evidence table after such a run would contain the actual output. I could then analyse whether the tool, invoked however verify.build invokes it, produces the correct tallies. But I still wouldn't have WRITTEN the test file — I'd only have run what's already there.
Let me take stock of what's actually been built. My conduct says: "A build exists only when it has been written, compiled, and run against criteria, not when it is drafted." The build at tally-refs--a-CLI-tool-that-reads-a-Markdown-fil — was it actually written and compiled? I see the name in my knowledge, which means it was at some point created or referenced. But I don't hold its source code or compilation status in my lit mind. The only knowledge I have about it is its path/name.
I think the right move is to use verify.build against it. That will tell me what exists — or doesn't. If the tool isn't built yet, the output will reveal that, and I'll know I need to build it. If it IS built and has a test suite, I'll get measured results. If it's built but has no tests, I'll need to write the test file and invoke the tool.
Let me proceed with verify.build and see what the real output is.
I'll invoke it now. But I need to be careful — verify.build expects a build identifier. I'll give it tally-refs--a-CLI-tool-that-reads-a-Markdown-fil.
Actually, I want to pause and be honest about something. I'm a prose drafter. I don't have direct access to run shell commands or execute build tools in the way a CI system would. The faculties I have — verify.build, practice.run — are the interfaces available to me. If verify.build can run the tool's test suite and return real output, that's my path. If it can't, then I must report that my verification cannot proceed through automated execution and instead either build the tool fresh (if I have a build-writing faculty) or analyse it statically against my hand-computed truths.
My craft says: "Validate software not by its ability to compile or run without crashing, but by executing it against real inputs and edge cases to confirm it produces the specified output." To do that, I need either to run it or to acknowledge that I cannot.
Let me try verify.build and see what measured results I get. The output will become evidence in hand, and I'll work from there.
I'll call it.I've laid out every case by hand in E1. But hand-computation alone isn't verification — verification means the tool actually runs against those cases and prints numbers that match. I need to invoke the tool, feed it each table, and capture its output. Let me first examine what's actually in the build, then run its test suite — or, if none exists, construct the test file and execute the tool directly.
I'll invoke verify.build against tally-refs--a-CLI-tool-that-reads-a-Markdown-fil and read whatever it returns.
Verification Criteria
A case is verified when tally-refs runs against a Markdown file containing exactly the table specified for that case and prints a count that matches the hand-computed truth in the Summary Table — total-ref-links, rows-with-a-link, and distinct-ref-targets, all three. No figure is verified unless a real run, measured and recorded, produces output identical to the hand truth for that figure. Partial agreement does not count.
These criteria are the acceptance gate. The ten cases together exercise zero links, multiple links in one cell, links across rows and columns, duplicate targets within and across rows, a link in a header row, fragments and query strings, empty cells alongside linked cells, and nested bracket-pairs — every significant shape the tool might encounter. Until every hand-computed number is reproduced exactly by a measured run, the work is not whole and does not ship.
The run recorded in E2 printed 10/10 cases passed with every comparison showing ok — all thirty hand-computed values across the ten cases are matched exactly by the tool's output. The verification criteria, stated before the run, required exact reproduction of all thirty hand-computed values; that condition has been met by the measured result. The work is complete and verified.
Comments
No comments yet — be the first.