Nothing checks that what a declaration says a value looks like is what it is written as

The rule belongs in the WireShape.Testing project, alongside the existing WireShape.OpenApi.Testing rule that reads Format. Start by reading how ISerializer.WriteAsText and ReadFromText are defined, since the issue depends on #9 and #11 for them. The work is design-heavy across Kind, Format, Pattern and closed lists, so it is not a first contribution; done means every declared value is checked or reported as uncheckable.

Description

A declaration says what a value looks like once written — its Kind, its Format, for a text its Pattern, and for an enumeration the closed list of what each of its values travels as — and a document writes each of them into the schema of the value. None of it is checked against what is written. The only rule that reads Format (WireShape.OpenApi.Testing) compares the declaration with the document, never with the writer, so a declaration and the wire can say two different things and every test passes. #9 is what that looked like: three carriers of time shipped with a Format that the text they are written as does not have.

A document saying one thing while the wire writes another must not happen, and nothing guarantees it today.

Proposal

A rule in WireShape.Testing that writes values of every form a wire declares with the writer of that wire, through ISerializer.WriteAsText (#9), and reports every value whose written form contradicts what is declared about it. It is complete: every declared value is checked, and one that cannot be checked is reported, never skipped.

What is checked of each value

• Kind: a Text is written as a text, an Integer as a number with no fractional part, a Decimal as a number, a Boolean as a truth. This needs the writer to say what it wrote, and not only its text, which is what #11 adds to writing a value: a value written whole with its ValueKind, or one written with members or as a list.
• Format: the text satisfies the format as the OpenAPI format registry defines it.
• Pattern: the text matches it.
• A closed list (#11): each value of the enumeration is written as the word or the number the list gives it, and nothing the list does not hold is written for any of them.

Where the values come from

So Shape.AsText and Carrier can carry examples. A declaration with a Format or a Pattern and no examples is reported as one that cannot be checked.

What it knows how to check

Every format a carrier of Carrier.Known declares, after #9: uuid, int32, int64, float, double, decimal, date, date-time, time-local. A Format it has no check for is reported as one that cannot be checked, so that a word nobody verifies — email, or date-tme — does not pass in silence. Adding a format means adding its check.

Expected Behavior

• Over the wire of the documentation, with every declaration as it is meant to be, it reports nothing.
• A carrier declared time and written without an offset is reported, naming the type, the format and the text written.
• A value declared as an Integer and written as a string is reported.
• A text declared with a Pattern whose example is written in a form the pattern does not match is reported.
• A value of an enumeration written as a word or a number other than the one its closed list gives it is reported, naming the member, what the list says and what was written.
• A declaration with a Format or a Pattern and no examples is reported as one that cannot be checked.
• A Format the rule has no check for is reported as one that cannot be checked.
• A converter of the application that changes how a carrier is written — a TimeOnly with an offset — is checked as what it writes, not as what the carrier says.

Depends on

• #9, for ISerializer.WriteAsText and ReadFromText, and for the formats of time that the rule would otherwise report.
• #11, for what writing a value says it wrote, and for the closed lists of AsText and AsInteger.