TestSet_EmbeddedStruct covers promoted fields. The embedded types are named with an initial capital on purpose: the embedded field takes the type's na

TestSet_EmptyContainerTagsAndJSONUnmarshaler pins which empty-container tags reach a custom UnmarshalJSON. The interface path withholds both `{}` and

TestSet_EmptyTag covers `default:""`, which is a request for the zero value rather than an absence: Set reads the tag with Tag.Lookup, so an empty tag

TestSet_ErrorStopsAtTheFirstField pins that Set gives up on the first failing field rather than collecting errors, so later fields keep their zero val

TestSet_FailingDefaultKeepsWhatWasNotZero pins the other side: a value Set did not find zero is not put back, so the caller's slice or map survives a

TestSet_FailingDefaultLeavesZeroValuesZero pins that a value Set found zero is zero again when a default below it fails, so a second Set meets the sam

TestSet_FailingUnmarshalerErrorIsReported covers a tag the type's own unmarshaler rejects and parsing by kind cannot take either. The error Set return

TestSet_FailingUnmarshalerFallsBackToKind covers what happens when the type's own unmarshaler rejects the value: the value is parsed by kind instead,

TestSet_FailingUnmarshalerWithNothingToFallBackTo covers a tag the type's own unmarshaler rejects when setField does not parse the type's kind at all:

TestSet_IntegerLiteralBases covers every width against every base, because the base is a parameter of the strconv call made per width: a `ParseInt(v,

TestSet_InterfaceFieldsAreNotFollowed pins that a non-nil interface is not descended into, even when it holds a pointer to a struct carrying tags. The

TestSet_InvalidDefaultErrorShape pins what the error carries: the field it came from, the tag that failed, and the underlying cause still reachable —

TestSet_InvalidTypeKeepsItsMessage pins the message of ErrInvalidType. Until the error was exported, matching on its message was the only way to tell

TestSet_LeadingZeroIsOctal pins that an integer tag is a Go integer literal all the way, legacy octal included: a leading zero makes the rest octal, s

TestSet_MapContainerValueIsNotStoredBack covers a slice or map held as a map value. Set fills a copy of it too, but the copy refers to the same elemen

TestSet_MapEntryUnderNaNKeyIsSkipped pins that an entry whose key is NaN gets no defaults. Each value is looked up by its key, and NaN never equals it

TestSet_MapOfNilPointersIsLeftAlone covers a nil pointer as a map value: there is nothing behind it to recurse into. A pointer map value is written th

TestSet_MapOfPointerContainers covers map values that point at a container rather than a struct. The element loop handles all three of struct, slice a

TestSet_MapOfScalarsIsLeftAlone pins that scalar map values are never rewritten: a zero value is not a field with a tag.

TestSet_MapOfStructsGetsDefaults covers a map of struct values the caller filled in. Values are not addressable, so each element is copied, defaulted,

TestSet_MapStructValueIsStoredBack pins that a struct held as a map value is stored back under its key once its copy is filled, whether or not anythin

TestSet_MapTagCreatesStructElements covers elements the tag itself creates: they are defaulted like any other element, and no other key appears.

TestSet_MapTagIsNotReappliedToElements pins that the element recursion is handed an empty tag: the parent's JSON builds the map once and is not decode

TestSet_NestedContainers covers containers nested inside one another, whether the caller built them or a tag did: the structs at the bottom get their

TestSet_NestedPointersAreAllocated covers arbitrary pointer depth: every level is allocated and the value lands at the bottom.

TestSet_NumberTagIsNotTrimmed pins the other side of that trim: it belongs to the duration attempt alone, so a padded number reaches the numeric parse

TestSet_NumericWidthBoundaries pins the bit size each numeric case parses with. Every case passes that width to strconv as a literal, and a wrong one

TestSet_OptOutDoesNotAffectOwnSetter covers the other side: opting a field out does not opt its own struct out of having its setter called.

TestSet_OptOutSkipsStructRecursionAndSetter covers the reach of `-` on a struct field: it is not descended into, so neither the nested tags nor the ne

TestSet_PointerFieldErrorIsReported covers a *struct field whose nested tag is invalid. That error used to be discarded, alone among the recursions, s

TestSet_PointerWithEmptyTag covers `default:""` on a pointer. The tag is present, so the pointer is allocated and points at the zero value — it used t

TestSet_PreservesNonInitialZeroLengthContainers pins that "non-initial" means "not deep-equal to the zero value", so an allocated but empty slice or m

TestSet_RecursiveTypeEnds covers types that repeat without their default recursing, which Set must walk to the end rather than reject. A repeat counts

TestSet_RejectsDefaultThatRecursesWithoutEnd covers a type that refers to itself through a field whose tag creates what it refers to: the default fill

TestSet_RejectsNil covers a nil, typed or not, which has no struct behind it to fill: it is rejected with the same error as any other non-struct-point

TestSet_SharedValueIsFilledOncePerPath covers a value the caller made reachable by more than one path. Set knows only the values on the path it is wal

TestSet_SharedValueIsFilledOncePerPathAtAnyDepth covers values shared far down a long path, where Set looks a value up in an index of the path instead

TestSet_SliceElementsGetDefaults covers a slice the caller filled in: Set descends into each element even though the field carries no tag.

TestSet_SliceOfScalarsIsLeftAlone pins that elements of a scalar slice are never rewritten: a zero element is not a field with a tag, so nothing appli

TestSet_SliceTagOverridesElementDefault covers precedence between a parent's tag and a child's own default: the parent wins.

TestSet_StructTagJSONWins covers precedence: what the parent's JSON provides is not overwritten by the child's own default.

TestSet_TextUnmarshalerArray covers an array type with a text form, the shape of uuid.UUID. setField does not parse an array by kind, but the tag is o

TestSet_TextUnmarshalerWinsOverJSON pins the precedence between the two interfaces.

TestSet_TextUnmarshalerWinsOverSetter pins the precedence the README claims. A successful UnmarshalText returns out of setField ahead of the recursion

TestSet_TimeTime covers the stdlib struct most likely to carry a default tag. It reaches time.Time's UnmarshalText, and a value that does not parse is

TestSet_UnexportedCompositeFieldsAreSkippedWholesale pins how far the CanSet guard reaches: an unexported field is skipped whatever its type, so a who

TestSet_UnexportedEmbeddedStructIsSkippedWholesale pins that the setter goes unapplied along with the tags when the unexported field is embedded; the

TestSet_UnexportedScalarFieldIsSkipped pins that an unexported field is untouched even with a tag (reflect cannot set it), and that its presence does

TestSet_UnmarshalerNeedsANonEmptyTag pins that neither interface is consulted for an empty tag, so a type that could unmarshal anything gets nothing f

TestSet_UnparsableValuesAreRejected covers a value the field's kind cannot parse: Set now returns an error naming the field, where it used to leave th

TestSet_UnsupportedKindsAreIgnored pins that kinds setField has no case for are left alone, tag or no tag, without an error. Only a tag that a type's

TestSet_UntaggedPointerStructRecurses covers the pointer a caller has already allocated: even with no tag, Set descends into it and fills its fields.

TestSet_WellFormedJSONOfTheWrongShape covers the other way decoding fails: valid JSON that cannot land in the field's type. It surfaces as *json.Unmar

TestSet_WhitespaceTagIsNotEmpty pins that a stray space is a value rather than an absence: a string takes it verbatim, and every container tries to de

TestSetter_CalledOnGenericStruct pins that a generic type's own setter is called. The compiler instantiates a generic method's code itself, so this gu