Set initializes members in a struct referenced by a pointer. Maps and slices are initialized by `make` and other primitive types are set with default

CanUpdate returns true when the given value is an initial value of its type

MustSet function is a wrapper of Set function It will call Set and panic if err not equals nil.

UnexportedField returns the field Set is expected to leave alone.

shouldInitializeField reports whether the field's own state warrants visiting it, regardless of any tag: a struct is always descended into, as is a po

SetDefaults derives a default that a tag cannot express, and CanUpdate keeps it from overriding what the caller already provided.

SetDefaults implements defaults.Setter interface

TestCanUpdate covers what "can update" means: deep-equal to the zero value of its own type. Note that an allocated-but-empty slice or map is therefore

TestCanUpdate_Nil covers a nil, which carries no type to compare against: there is nothing there to preserve, so it is updatable. It used to panic ins

TestSet_ArraysAreLeftAlone pins that reflect.Array has no case in setField, which makes an array behave unlike the slice of the same element type: its

TestSet_ByteSlice covers []byte, where encoding/json accepts two spellings and rejects bare text.

TestSet_CannotPreserveFalseBool pins the one type whose caller-provided value is indistinguishable from "unset": a bool. An explicit false is overwrit

TestSet_DeepContainersFromTag covers nesting created entirely by a tag, rather than by the caller.

TestSet_DurationAndIntegerShareOneParser pins the outcomes of int64-kinded fields being handed to both time.ParseDuration and strconv.ParseInt: a bare

TestSet_DurationStringOnANarrowerIntegerIsRejected pins that the duration fallback is int64-only. A narrower width rejects a duration string outright,

TestSet_DurationTagIsTrimmed covers a duration tag carrying surrounding whitespace, which used to leave the field at zero. The trim happens where Pars

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_FailingUnmarshalerFallsBackToKind covers what happens when the type's own unmarshaler rejects the value: the error is not reported, and the va

TestSet_ForeignPackageUnexportedField covers a struct declared in another package: the exported field is set, the unexported one is out of reflect's r

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_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_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_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_PanicsOnNil pins that a nil argument is not rejected but fatal: the type switch happens before any validation. QUIRK: arguably these should r

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_SliceElementsGetDefaults covers a slice the caller filled in: Set descends into each element even though the field carries no tag.