Loading the parity record
Fetching the measured run — the pinned upstream oracle, every symbol and every case.
Fetching the measured run — the pinned upstream oracle, every symbol and every case.
Parity / YAML
Every number on this page was produced by running both implementations over the same cases: the real yaml package pinned at 2.6.1 answers first, and its answer is the expectation the Go port is held to. Nothing is a hand-written expectation, so a new upstream release re-scores the port on its own. See YAML for the port's own documentation. Source: github.com/malcolmston/yaml.
Not a generic diagram: every node below names an artefact of this harness — the pinned package it installed, the runner files it started, the case files it streamed, and the counts it wrote out.
| Case group | Cases | Match | Mismatch | Group parity |
|---|---|---|---|---|
| suite-accept | 308 | 304 | 4 | 98.7% |
| suite-reemit | 308 | 262 | 45 | 85.1% |
| suite-json | 279 | 273 | 5 | 97.8% |
| suite-fail | 94 | 92 | 2 | 97.9% |
| schema-1-1-vs-1-2 | 24 | 17 | 4 | 70.8% |
| emitter-bugs | 23 | 8 | 13 | 34.8% |
| emit-values | 18 | 17 | 1 | 94.4% |
| stream | 17 | 17 | 0 | 100.0% |
Every exported symbol of the upstream package, and what the port offers for it. The upstream list is derived mechanically, never from a README: cd node && node -e "console.log(Object.keys(require('yaml')).sort().join('\n'))". A symbol with no case is untested, never a match.
| Upstream symbol | Go symbol | Status | Cases | Note |
|---|---|---|---|---|
| yaml.parse | yaml.Unmarshal | match | unmarshal-* (6) | |
| yaml.parseAllDocuments | yaml.Parse, yaml.NewDecoder/Decoder.Decode | differs | accept-* (308), fail-* (94), decode-stream-* (5) | port drops empty documents; port accepts duplicate keys |
| yaml.parseDocument | yaml.Parse (first document) | differs | reemit-* (308), emit-* | see the emitter defects above |
| yaml.stringify | yaml.Marshal, Encoder.Encode | differs | marshal-* (18), encode-stream-* (6) | "\n" round-trips to "" |
| yaml.Document | yaml.Node (DocumentNode) | differs | reemit-*, comment cases | |
| yaml.Scalar | yaml.Node (ScalarNode) | differs | reemit-* | tag/anchor/comment emission |
| yaml.YAMLMap | yaml.Node (MappingNode) | differs | reemit-* | complex keys cannot be decoded |
| yaml.YAMLSeq | yaml.Node (SequenceNode) | differs | reemit-* | |
| yaml.Alias | yaml.Node (AliasNode), Node.Alias | differs | reemit-E76Z, reemit-X38W, unmarshal-anchors | alias-as-key emitted without a space |
| yaml.Pair | — | missing | — | the port stores a mapping as alternating Node.Content, with no key/value pair type |
| yaml.Schema | — | missing | — | the schema is fixed to YAML 1.2 core; not selectable |
| yaml.Composer | — | missing | — | no separately exposed event-to-tree stage |
| yaml.Parser | — | missing | — | no exposed event parser |
| yaml.Lexer | — | missing | — | no exposed lexer |
| yaml.CST | — | missing | — | no concrete syntax tree / lossless source model |
| yaml.LineCounter | Node.Line, Node.Column | missing | — | positions are on the node; no offset-to-line utility |
| yaml.visit | — | missing | — | no tree visitor (Node.Content is walked by hand) |
| yaml.visitAsync | — | missing | — | |
| yaml.YAMLError | yaml.ErrSyntax and friends | untested | — | only *whether* a call failed is compared, never the message (per HARNESS.md) |
| yaml.YAMLParseError | *yaml.SyntaxError | untested | — | carries line/column on both sides; not compared |
| yaml.YAMLWarning | — | missing | — | the port has no recoverable-warning channel; it either fails or succeeds |
| yaml.isNode | Node.IsZero (nearest) | untested | — | Go uses the concrete *Node type, so no predicate is needed |
| yaml.isDocument | Node.Kind == DocumentNode | untested | — | |
| yaml.isMap | Node.Kind == MappingNode | untested | — | |
| yaml.isSeq | Node.Kind == SequenceNode | untested | — | |
| yaml.isScalar | Node.Kind == ScalarNode | untested | — | |
| yaml.isAlias | Node.Kind == AliasNode | untested | — | |
| yaml.isPair | — | missing | — | no pair type |
| yaml.isCollection | Node.Kind & (SequenceNode|MappingNode) | untested | — | Kind is a bit set for exactly this |
| — | yaml.Marshal | differs | marshal-* (18), reemit-* (308) | defects A–E |
| — | yaml.Unmarshal | match | unmarshal-* (6) | |
| — | yaml.Parse | differs | accept-* (308), fail-* (94) | drops empty documents; accepts duplicate keys; accepts ill-formed UTF-8 |
| — | yaml.NewDecoder | match | decode-stream-* (5) | |
| — | (*Decoder).Decode | match | decode-stream-* (5) | including the io.EOF terminator |
| — | yaml.NewEncoder | match | encode-stream-* (6) | |
| — | (*Encoder).Encode | match | encode-stream-* (6) | |
| — | (*Encoder).Close | match | encode-stream-* (6) | |
| — | (*Encoder).SetIndent | match | encode-stream-one-2, encode-stream-one-4 | value survives at both indents |
| — | (*Node).Decode | differs | json-* (279), reemit-* | cannot decode collection keys (13 cases) |
| — | (*Node).Encode | differs | emit-line-comment*, emit-head-comment, emit-foot-comment | see defect E |
| — | yaml.Node.Kind | untested | — | not observable through a JSON value |
| — | yaml.Node.Tag | differs | defect A/C tables | doubled in flow style, emitted bare when global, dropped for !!timestamp |
| — | yaml.Node.Value | untested | — | compared only through the decoded value |
| — | yaml.Node.Anchor | differs | reemit-CN3R, reemit-6BFJ, reemit-E76Z | doubled in flow style; alias key emitted without a space |
| — | yaml.Node.Alias | differs | reemit-X38W, reemit-E76Z | |
| — | yaml.Node.Content | untested | — | structural; compared only through the decoded value |
| — | yaml.Node.Style | differs | emit-flow-*, reemit-K858, reemit-JEF9-01/02 | FlowStyle + tag doubles the tag; LiteralStyle loses a lone "\n" |
| — | yaml.Node.Line / .Column | untested | — | positions are not part of any compared value |
| — | yaml.Node.HeadComment | untested | emit-head-comment, emit-head-comment-roundtrip | the cases pass, but a head comment does not change the decoded value, so they cannot prove the text is right |
| — | yaml.Node.LineComment | differs | emit-line-comment, emit-line-comment-string | defect E — written with no # |
| — | yaml.Node.FootComment | differs | emit-foot-comment-growth*, reemit-F8F9, reemit-JHB9 | defect D — duplicated per round trip |
| — | (*Node).ShortTag | untested | — | no oracle counterpart in yaml@2 |
| — | (*Node).LongTag | untested | — | |
| — | (*Node).IsZero | untested | — | |
| — | (*Node).SetString | untested | — | |
| — | (Kind).String | untested | — | Go-only, no counterpart |
| — | yaml.Kind + DocumentNode/SequenceNode/MappingNode/ScalarNode/AliasNode | untested | — | not observable through a JSON value |
| — | yaml.Style + TaggedStyle/FlowStyle | differs | emit-flow-* | |
| — | yaml.Style + DoubleQuotedStyle/SingleQuotedStyle | match | every double- and single-tagged suite case re-emits (33/33 and 6/6) | |
| — | yaml.Style + FoldedStyle | differs | reemit-F6MC | a folded scalar with a more-indented first line re-emits as an unparseable literal block (21/25 folded cases re-emit) |
| — | yaml.Style + LiteralStyle | differs | reemit-K858, reemit-JEF9-01/02, marshal-multiline | a lone "\n" becomes "" (31/36 literal cases re-emit) |
| — | NullTag/BoolTag/IntTag/FloatTag/StringTag | match | schema-*, json-* | resolution agrees with the oracle and the suite |
| — | SequenceTag/MappingTag | match | json-* | |
| — | BinaryTag | differs | parse-binary-tag, json-565N | documented deviation (decoded) |
| — | TimestampTag | differs | emit-timestamp-tag*, parse-timestamp-tag | dropped on emit |
| — | MergeTag | differs | schema-merge-key | documented deviation (resolved by default) |
| — | ErrAliasBomb | differs | schema-alias-bomb | documented deviation (higher threshold than the oracle) |
| — | ErrSyntax | untested | — | only failure/success is compared, not the sentinel |
| — | ErrUnknownAnchor | untested | — | observed in defect A messages, not asserted |
| — | ErrTypeMismatch | untested | — | |
| — | ErrUnsupportedType | untested | — | |
| — | ErrInvalidUnmarshal | untested | — | not reachable from a JSON-Lines case |
| — | ErrClosed | untested | — | |
| — | *SyntaxError (.Line, .Column, .Msg, .Error, .Unwrap) | untested | — | positions are not compared |
| — | *TypeError (.Errors, .Error, .Unwrap) | untested | — | |
| — | yaml.Marshaler | untested | — | Go-only extension point; no oracle counterpart |
| — | yaml.Unmarshaler | untested | — | Go-only extension point |
Every case the harness streamed to both runners, with the exact upstream symbol and Go symbol it exercised. A deliberate, documented difference is a deviation and is counted apart from a mismatch.
| Case | Group | Upstream symbol | Go symbol | Status | Note |
|---|---|---|---|---|---|
| marshal-scalars | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | plain scalars |
| marshal-string-yes | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | strings a YAML 1.1 reader would take for booleans |
| marshal-string-null | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | strings that would be read back as null |
| marshal-string-numeric | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | strings that would be read back as numbers |
| marshal-string-indicators | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | strings starting with, or containing, YAML indicators |
| marshal-string-whitespace | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | significant whitespace |
| marshal-multiline | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | mismatch | multi-line strings: a literal block scalar must round-trip exactly |
| marshal-unicode | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | non-ASCII |
| marshal-control-chars | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | control characters have to be escaped |
| marshal-nested | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | nesting |
| marshal-empty-collections | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | empty sequence and mapping |
| marshal-seq-root | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | a sequence at the document root |
| marshal-scalar-root | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | a scalar at the document root |
| marshal-null-root | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | null at the document root |
| marshal-long | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | long keys and values -- line folding must not change the value |
| marshal-numbers-edge | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | numeric edges |
| marshal-deep | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | deep nesting |
| marshal-key-lookalikes | emit-values | String(new yaml.Document(v)) | yaml.Marshal(v) | match | keys that need quoting |
| emit-flow-seq-tag | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 1: a tag on a flow sequence is emitted twice (!lst !lst [1, 2]) and no longer parses |
| emit-flow-map-tag | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 1: same doubling for a flow mapping |
| emit-flow-seq-tag-nested | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 1: doubled tag on a flow sequence used as a mapping value |
| emit-block-seq-tag-control | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | match | control for bug 1: a tag on a BLOCK collection is expected to survive |
| emit-verbatim-global-tag | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 2: a global/URI tag is emitted as a bare URI, so it re-parses as a plain string -- silent data corruption |
| emit-tag-directive-global | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 2: %TAG is resolved away and the expanded URI is emitted bare |
| emit-tag-directive-secondary | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 2: secondary tag handle, same bare-URI emission |
| emit-local-tag-control | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | match | control for bug 2: a local tag (!custom) is expected to survive |
| emit-line-comment | emitter-bugs | node.comment = text | Node.LineComment = text | mismatch | bug 3: LineComment is written without a leading '#', so 'why' is absorbed into the value |
| emit-line-comment-string | emitter-bugs | node.comment = text | Node.LineComment = text | mismatch | bug 3: same absorption when the value is a string |
| emit-head-comment | emitter-bugs | node.commentBefore = text | Node.HeadComment = text | match | HeadComment set on a mapping value node |
| emit-foot-comment | emitter-bugs | doc.comment = text | Node.FootComment = text | match | FootComment set on the root mapping |
| emit-foot-comment-growth | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 4: a foot comment is duplicated on every round trip, so the document grows without bound (grew:true) |
| emit-foot-comment-growth-seq | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 4: same growth under a sequence |
| emit-head-comment-roundtrip | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | match | control for bug 4: a head comment is expected to be stable across round trips |
| emit-timestamp-tag | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 5: !!timestamp is dropped on emit, so the value comes back as a plain string |
| emit-timestamp-tag-spaced | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | bug 5: !!timestamp written in the YAML spaced form |
| parse-timestamp-tag | emitter-bugs | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | !!timestamp resolution, before any emitting is involved |
| utf8-illformed-accept | emitter-bugs | yaml.parseAllDocuments | yaml.Parse | match | bug 6: the port accepts ill-formed UTF-8 (0xff 0xfe). A JavaScript string cannot hold ill-formed bytes at all, so this case can only record that the port does not reject them |
| utf8-illformed-is-illformed | emitter-bugs | Buffer round trip | utf8.Valid | match | asserts the fixture really is ill-formed UTF-8, on both sides |
| utf8-illformed-reemit | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | deviation | a JavaScript string cannot hold ill-formed UTF-8, so the oracle only ever sees latin1-decoded bytes; nothing but acceptance is comparable here |
| emit-binary-tag | emitter-bugs | String(yaml.parseDocument(...)) | yaml.Parse + yaml.Marshal(*yaml.Node) | mismatch | !!binary round trip |
| parse-binary-tag | emitter-bugs | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | deviation | API-DEVIATIONS.md, "!!binary is decoded" |
| schema-bool-yes-no | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 booleans; the 1.2 core schema makes these strings |
| schema-bool-on-off | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 booleans |
| schema-bool-y-n | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 single-letter booleans |
| schema-bool-case | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | capitalisation of booleans |
| schema-bool-true-false | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.2 core booleans |
| schema-null-tilde | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | null spellings, including the empty value |
| schema-int-leading-zero | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 octal; the 1.2 core schema has no leading-zero octal |
| schema-int-octal-1-2 | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.2 octal |
| schema-int-hex | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | mismatch | hexadecimal |
| schema-int-binary | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 binary; not in the 1.2 core schema |
| schema-int-underscores | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 digit separators |
| schema-int-plus | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | signed integers |
| schema-sexagesimal | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | 1.1 sexagesimal; the 1.2 core schema makes these strings |
| schema-float-forms | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | float spellings |
| schema-float-specials | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | infinities and not-a-number |
| schema-float-specials-11 | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | spellings that are NOT in the 1.2 core schema |
| schema-explicit-tags | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | mismatch | explicit tags override resolution |
| schema-empty-string | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | quoted empty scalars stay strings |
| schema-string-lookalikes | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | match | quoting defeats resolution |
| schema-big-int | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | deviation | a JavaScript number cannot represent this exactly; the port keeps full precision |
| schema-dup-keys | schema-1-1-vs-1-2 | yaml.parseAllDocuments | yaml.Parse | mismatch | duplicate mapping keys |
| schema-complex-key | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | mismatch | a sequence used as a mapping key |
| schema-merge-key | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | deviation | the port resolves merge keys by default; yaml@2 needs {merge: true} and otherwise keeps a literal "<<" key |
| schema-alias-bomb | schema-1-1-vs-1-2 | yaml.parseAllDocuments().map(d => d.toJS()) | yaml.Parse + (*Node).Decode | deviation | API-DEVIATIONS.md, "Alias-expansion budget": the port allows 1<<21 nodes, where yaml@2 rejects this document outright |
| unmarshal-map | stream | yaml.parse | yaml.Unmarshal | match | single-document decode |
| unmarshal-scalar | stream | yaml.parse | yaml.Unmarshal | match | a scalar document |
| unmarshal-empty | stream | yaml.parse | yaml.Unmarshal | match | an empty stream |
| unmarshal-nested | stream | yaml.parse | yaml.Unmarshal | match | nesting |
| unmarshal-anchors | stream | yaml.parse | yaml.Unmarshal | match | anchor and alias |
| unmarshal-invalid | stream | yaml.parse | yaml.Unmarshal | match | a malformed document must fail on both sides |
| decode-stream-three | stream | yaml.parseAllDocuments | yaml.NewDecoder + Decoder.Decode | match | three documents |
| decode-stream-one | stream | yaml.parseAllDocuments | yaml.NewDecoder + Decoder.Decode | match | one document, no markers |
| decode-stream-empty | stream | yaml.parseAllDocuments | yaml.NewDecoder + Decoder.Decode | match | an empty stream |
| decode-stream-mixed | stream | yaml.parseAllDocuments | yaml.NewDecoder + Decoder.Decode | match | documents of different shapes |
| decode-stream-invalid | stream | yaml.parseAllDocuments | yaml.NewDecoder + Decoder.Decode | match | a stream whose second document is malformed |
| encode-stream-one-2 | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | one document at indent 2 |
| encode-stream-one-4 | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | one document at indent 4 |
| encode-stream-three | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | three documents |
| encode-stream-nulls | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | nulls at document and value level |
| encode-stream-nested | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | nesting at indent 2 |
| encode-stream-quoting | stream | yaml.stringify(v, {indent}) | yaml.NewEncoder + SetIndent + Encode + Close | match | values that must be quoted to survive |
| accept-229Q | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Spec Example 2.4. Sequence of Mappings |
| accept-26DV | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Whitespace around colon in mappings |
| accept-27NA | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Spec Example 5.9. Directive Indicator |
| accept-2AUY | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Tags in Block Sequence |
| accept-2EBW | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Allowed characters in keys |
| accept-2G84-02 | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Literal modifers |
| accept-2G84-03 | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Literal modifers |
| accept-2JQS | suite-accept | yaml.parseAllDocuments | yaml.Parse | mismatch | Block Mapping with Missing Keys |
| accept-2LFX | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Spec Example 6.13. Reserved Directives [1.3] |
| accept-2SXE | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Anchors With Colon in Name |
| accept-2XXW | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Spec Example 2.25. Unordered Sets |
| accept-33X3 | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Three explicit integers in a block sequence |
| accept-35KP | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Tags for Root Objects |
| accept-36F6 | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Multiline plain scalar with empty line |
| accept-3ALJ | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Block Sequence in Block Sequence |
| accept-3GZX | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Spec Example 7.1. Alias Nodes |
| accept-3MYT | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Plain Scalar looking like key, comment, anchor and tag |
| accept-3R3P | suite-accept | yaml.parseAllDocuments | yaml.Parse | match | Single block sequence with anchor |