typia 13.1.19 → 13.2.0

package/native/core/programmers/helpers/joiner_branch_coverage_test.go

@@ -4,11 +4,11 @@
 package helpers
 
 import (
-	"testing"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestJoinerBranchCoverage exercises joiner helper branches.
@@ -23,127 +23,123 @@ import (
 // 3. Exercise function programmer variable declaration and declaration-disable branches.
 // 4. Verify string joining, internal import fallback, and metadata pattern helpers.
 func TestJoinerBranchCoverage(t *testing.T) {
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	value := factory.NewIdentifier("value")
-	literalKey := helperLiteralKey("known")
-	dynamicKey := helperAtomic("string")
-	numberKey := helperAtomic("number")
-	booleanKey := helperAtomic("boolean")
-	templateKey := nativemetadata.MetadataSchema_initialize()
-	templateKey.Templates = append(templateKey.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
-		Row: []*nativemetadata.MetadataSchema{literalKey, numberKey},
-	}))
-	required := helperAtomic("string")
-	optional := helperAtomic("string")
-	optional.Optional = true
-	optional.Required = false
-	functional := nativemetadata.MetadataSchema_initialize()
-	functional.Functions = append(functional.Functions, nativemetadata.MetadataFunction_create(nativemetadata.MetadataFunction{
-		Output: helperAtomic("string"),
-	}))
-	entries := []IExpressionEntry{
-		{Input: input, Key: literalKey, Meta: required, Expression: value},
-		{Input: input, Key: dynamicKey, Meta: optional, Expression: value},
-	}
-	if CloneJoiner.Tuple(CloneJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		CloneJoiner.Array(CloneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
-		CloneJoiner.Object(CloneJoiner_ObjectProps{Input: input, Entries: entries}) == nil {
-		t.Fatal("clone joiner returned nil")
-	}
-	if NotationJoiner.Object(NotationJoiner_ObjectProps{
-		Rename:        func(str string) string { return str },
-		DynamicRename: func() *shimast.Node { return factory.NewIdentifier("rename") },
-		DynamicAssign: func() *shimast.Node { return factory.NewIdentifier("assign") },
-		Input:         input,
-		Entries:       entries,
-	}) == nil ||
-		NotationJoiner.Tuple(NotationJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		NotationJoiner.Array(NotationJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
-		t.Fatal("notation joiner returned nil")
-	}
-	object := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
-		Name: "Object",
-		Properties: []*nativemetadata.MetadataProperty{
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literalKey, Value: required}),
-			nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: dynamicKey, Value: required}),
-		},
-	})
-	if PruneJoiner.Tuple(PruneJoiner_TupleProps{Elements: []*shimast.ConciseBody{value}, Rest: value}) == nil ||
-		PruneJoiner.Array(PruneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
-		PruneJoiner.Object(PruneJoiner_ObjectProps{Input: input, Entries: entries, Object: object}) == nil {
-		t.Fatal("prune joiner returned nil")
-	}
-	if StringifyJoiner.Tuple(StringifyJoiner_TupleProps{}) == nil ||
-		StringifyJoiner.Tuple(StringifyJoiner_TupleProps{
-			Elements: []*shimast.Expression{
-				factory.NewStringLiteral("a", shimast.TokenFlagsNone),
-				factory.NewStringLiteral("b", shimast.TokenFlagsNone),
-			},
-		}) == nil ||
-		StringifyJoiner.Tuple(StringifyJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
-		StringifyJoiner.Array(StringifyJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
-		t.Fatal("stringify tuple or array joiner returned nil")
-	}
-	stringifyEntries := []IExpressionEntry{
-		{Input: input, Key: literalKey, Meta: functional, Expression: value},
-		{Input: input, Key: dynamicKey, Meta: optional, Expression: value},
-	}
-	if StringifyJoiner.Object(StringifyJoiner_ObjectProps{Context: nativecontext.ITypiaContext{}, Entries: stringifyEntries}) == nil {
-		t.Fatal("stringify object joiner returned nil")
-	}
-	if stringifyJoiner_regular_condition(IExpressionEntry{Input: input, Meta: functional}) == nil ||
-		stringifyJoiner_regular_arrow() == nil ||
-		stringifyJoiner_binding_pattern() == nil ||
-		stringifyJoiner_reduce([]*shimast.Node{input, value}, shimast.KindAmpersandAmpersandToken) == nil ||
-		stringifyJoiner_internal(nativecontext.ITypiaContext{}, "helper") == nil {
-		t.Fatal("stringify helper returned nil")
-	}
-	if joinStrings([]string{}, ",") != "" || joinStrings([]string{"a", "b"}, ",") != "a,b" {
-		t.Fatal("joinStrings returned unexpected output")
-	}
-	if cloneJoiner_regular_skip([]IExpressionEntry{{Key: literalKey}}) == nil ||
-		cloneJoiner_metadata_to_pattern(struct {
-			top      bool
-			metadata *nativemetadata.MetadataSchema
-		}{top: true, metadata: booleanKey}) == "" ||
-		cloneJoiner_metadata_to_pattern(struct {
-			top      bool
-			metadata *nativemetadata.MetadataSchema
-		}{top: true, metadata: templateKey}) == "" ||
-		cloneJoiner_template_to_pattern(struct {
-			top      bool
-			template []*nativemetadata.MetadataSchema
-		}{top: true, template: []*nativemetadata.MetadataSchema{literalKey, numberKey}}) == "" {
-		t.Fatal("clone pattern helper returned empty output")
-	}
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("input")
+  value := factory.NewIdentifier("value")
+  literalKey := helperLiteralKey("known")
+  dynamicKey := helperAtomic("string")
+  numberKey := helperAtomic("number")
+  booleanKey := helperAtomic("boolean")
+  templateKey := nativemetadata.MetadataSchema_initialize()
+  templateKey.Templates = append(templateKey.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
+    Row: []*nativemetadata.MetadataSchema{literalKey, numberKey},
+  }))
+  required := helperAtomic("string")
+  optional := helperAtomic("string")
+  optional.Optional = true
+  optional.Required = false
+  functional := nativemetadata.MetadataSchema_initialize()
+  functional.Functions = append(functional.Functions, nativemetadata.MetadataFunction_create(nativemetadata.MetadataFunction{
+    Output: helperAtomic("string"),
+  }))
+  entries := []IExpressionEntry{
+    {Input: input, Key: literalKey, Meta: required, Expression: value},
+    {Input: input, Key: dynamicKey, Meta: optional, Expression: value},
+  }
+  if CloneJoiner.Tuple(CloneJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    CloneJoiner.Array(CloneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
+    CloneJoiner.Object(CloneJoiner_ObjectProps{Input: input, Entries: entries}) == nil {
+    t.Fatal("clone joiner returned nil")
+  }
+  if NotationJoiner.Object(NotationJoiner_ObjectProps{
+    Rename:        func(str string) string { return str },
+    DynamicRename: func() *shimast.Node { return factory.NewIdentifier("rename") },
+    DynamicAssign: func() *shimast.Node { return factory.NewIdentifier("assign") },
+    Input:         input,
+    Entries:       entries,
+  }) == nil ||
+    NotationJoiner.Tuple(NotationJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    NotationJoiner.Array(NotationJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
+    t.Fatal("notation joiner returned nil")
+  }
+  object := nativemetadata.MetadataObjectType_create(nativemetadata.MetadataObjectType{
+    Name: "Object",
+    Properties: []*nativemetadata.MetadataProperty{
+      nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: literalKey, Value: required}),
+      nativemetadata.MetadataProperty_create(nativemetadata.MetadataProperty{Key: dynamicKey, Value: required}),
+    },
+  })
+  if PruneJoiner.Tuple(PruneJoiner_TupleProps{Elements: []*shimast.ConciseBody{value}, Rest: value}) == nil ||
+    PruneJoiner.Array(PruneJoiner_ArrayProps{Input: input, Arrow: value}) == nil ||
+    PruneJoiner.Object(PruneJoiner_ObjectProps{Input: input, Entries: entries, Object: object}) == nil {
+    t.Fatal("prune joiner returned nil")
+  }
+  if StringifyJoiner.Tuple(StringifyJoiner_TupleProps{}) == nil ||
+    StringifyJoiner.Tuple(StringifyJoiner_TupleProps{
+      Elements: []*shimast.Expression{
+        factory.NewStringLiteral("a", shimast.TokenFlagsNone),
+        factory.NewStringLiteral("b", shimast.TokenFlagsNone),
+      },
+    }) == nil ||
+    StringifyJoiner.Tuple(StringifyJoiner_TupleProps{Elements: []*shimast.Expression{value}, Rest: input}) == nil ||
+    StringifyJoiner.Array(StringifyJoiner_ArrayProps{Input: input, Arrow: value}) == nil {
+    t.Fatal("stringify tuple or array joiner returned nil")
+  }
+  stringifyEntries := []IExpressionEntry{
+    {Input: input, Key: literalKey, Meta: functional, Expression: value},
+    {Input: input, Key: dynamicKey, Meta: optional, Expression: value},
+  }
+  if StringifyJoiner.Object(StringifyJoiner_ObjectProps{Context: nativecontext.ITypiaContext{}, Entries: stringifyEntries}) == nil {
+    t.Fatal("stringify object joiner returned nil")
+  }
+  if stringifyJoiner_regular_condition(IExpressionEntry{Input: input, Meta: functional}) == nil ||
+    stringifyJoiner_regular_arrow() == nil ||
+    stringifyJoiner_binding_pattern() == nil ||
+    stringifyJoiner_reduce([]*shimast.Node{input, value}, shimast.KindAmpersandAmpersandToken) == nil ||
+    stringifyJoiner_internal(nativecontext.ITypiaContext{}, "helper") == nil {
+    t.Fatal("stringify helper returned nil")
+  }
+  if joinStrings([]string{}, ",") != "" || joinStrings([]string{"a", "b"}, ",") != "a,b" {
+    t.Fatal("joinStrings returned unexpected output")
+  }
+  if cloneJoiner_regular_skip([]IExpressionEntry{{Key: literalKey}}) == nil ||
+    cloneJoiner_metadata_to_pattern(struct {
+      top      bool
+      metadata *nativemetadata.MetadataSchema
+    }{top: true, metadata: booleanKey}) == "" ||
+    cloneJoiner_metadata_to_pattern(struct {
+      top      bool
+      metadata *nativemetadata.MetadataSchema
+    }{top: true, metadata: templateKey}) == "" ||
+    cloneJoiner_template_to_pattern(struct {
+      top      bool
+      template []*nativemetadata.MetadataSchema
+    }{top: true, template: []*nativemetadata.MetadataSchema{literalKey, numberKey}}) == "" {
+    t.Fatal("clone pattern helper returned empty output")
+  }
 
-	programmer := NewFunctionProgrammer("joiner")
-	if programmer.EmplaceVariable("cached", value) == nil || len(programmer.Declare(false)) == 0 {
-		t.Fatal("function programmer variable branch failed")
-	}
-	programmer.disableDeclare = true
-	if len(programmer.Declare()) != 0 || len(programmer.DeclareUnions()) != 0 {
-		t.Fatal("disabled function programmer should not declare")
-	}
-	if stringifyJoiner_internal(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, "jsonStringifyTail") == nil {
-		t.Fatal("stringify internal importer branch returned nil")
-	}
+  programmer := NewFunctionProgrammer("joiner")
+  if programmer.EmplaceVariable("cached", value) == nil || len(programmer.Declare(false)) == 0 {
+    t.Fatal("function programmer variable branch failed")
+  }
+  if stringifyJoiner_internal(nativecontext.ITypiaContext{Importer: nativecontext.NewImportProgrammer()}, "jsonStringifyTail") == nil {
+    t.Fatal("stringify internal importer branch returned nil")
+  }
 }
 
 func helperLiteralKey(value string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "string",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
-		},
-	}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Constants = append(meta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "string",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: value}),
+    },
+  }))
+  return meta
 }
 
 func helperAtomic(kind string) *nativemetadata.MetadataSchema {
-	meta := nativemetadata.MetadataSchema_initialize()
-	meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
-	return meta
+  meta := nativemetadata.MetadataSchema_initialize()
+  meta.Atomics = append(meta.Atomics, nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: kind}))
+  return meta
 }

package/native/core/programmers/iterate/iterate_check_coverage_test.go

@@ -4,175 +4,93 @@
 package iterate
 
 import (
-	"testing"
+  "testing"
 
-	shimast "github.com/microsoft/typescript-go/shim/ast"
-	shimprinter "github.com/microsoft/typescript-go/shim/printer"
-	nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
-	nativefactories "github.com/samchon/typia/packages/typia/native/core/factories"
-	nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
-	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativehelpers "github.com/samchon/typia/packages/typia/native/core/programmers/helpers"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
 )
 
 // TestIterateCheckCoverage exercises dynamic and union check helpers.
 //
 // Dynamic object and array-like union checks are selected only for particular
 // metadata shapes. This test constructs those shapes directly and verifies each
-// helper returns AST nodes for dynamic keys, dynamic properties, and union arrays.
+// helper returns AST nodes for dynamic keys and dynamic properties.
 //
 // 1. Check dynamic key branches for nullable, optional, atomic, constant, template, and native keys.
 // 2. Check dynamic object property branches with equals, undefined, and superfluous handling.
-// 3. Check tuple and array union disambiguation with a custom accessor.
-// 4. Verify explore-map and return-wrapping helper behavior.
 func TestIterateCheckCoverage(t *testing.T) {
-	emit := shimprinter.NewEmitContext()
-	factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
-	input := factory.NewIdentifier("input")
-	keyMeta := nativemetadata.MetadataSchema_initialize()
-	keyMeta.Nullable = true
-	keyMeta.Required = false
-	keyMeta.Optional = true
-	keyMeta.Atomics = append(keyMeta.Atomics,
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "boolean"}),
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "number"}),
-		nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "bigint"}),
-	)
-	keyMeta.Constants = append(keyMeta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
-		Type: "string",
-		Values: []*nativemetadata.MetadataConstantValue{
-			nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: "fixed"}),
-		},
-	}))
-	keyMeta.Templates = append(keyMeta.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
-		Row: []*nativemetadata.MetadataSchema{iterateLiteral("x"), iterateAtomic("number")},
-	}))
-	keyMeta.Natives = append(keyMeta.Natives,
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Boolean"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "BigInt"}),
-		nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Number"}),
-	)
-	if Check_dynamic_key(Check_dynamic_keyProps{
-		Context:  nativecontext.ITypiaContext{},
-		Metadata: keyMeta,
-		Input:    input,
-	}) == nil || check_dynamic_key_strict_equal(input, input) == nil ||
-		check_dynamic_key_internal(nativecontext.ITypiaContext{}, "helper") == nil {
-		t.Fatal("dynamic key helper returned nil")
-	}
-	if check_dynamic_key_atomist(nativehelpers.ICheckEntry{
-		Expression: input,
-		Conditions: [][]nativehelpers.ICheckEntry_ICondition{{
-			{Expression: input},
-		}},
-	}) == nil || check_dynamic_key_reduce(nil, shimast.KindBarBarToken) == nil {
-		t.Fatal("dynamic key atomist or reducer returned nil")
-	}
+  factory := shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+  input := factory.NewIdentifier("input")
+  keyMeta := nativemetadata.MetadataSchema_initialize()
+  keyMeta.Nullable = true
+  keyMeta.Required = false
+  keyMeta.Optional = true
+  keyMeta.Atomics = append(keyMeta.Atomics,
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "boolean"}),
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "number"}),
+    nativemetadata.MetadataAtomic_create(nativemetadata.MetadataAtomic{Type: "bigint"}),
+  )
+  keyMeta.Constants = append(keyMeta.Constants, nativemetadata.MetadataConstant_create(nativemetadata.MetadataConstant{
+    Type: "string",
+    Values: []*nativemetadata.MetadataConstantValue{
+      nativemetadata.MetadataConstantValue_create(nativemetadata.MetadataConstantValue{Value: "fixed"}),
+    },
+  }))
+  keyMeta.Templates = append(keyMeta.Templates, nativemetadata.MetadataTemplate_create(nativemetadata.MetadataTemplate{
+    Row: []*nativemetadata.MetadataSchema{iterateLiteral("x"), iterateAtomic("number")},
+  }))
+  keyMeta.Natives = append(keyMeta.Natives,
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Boolean"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "BigInt"}),
+    nativemetadata.MetadataNative_create(nativemetadata.MetadataNative{Name: "Number"}),
+  )
+  if Check_dynamic_key(Check_dynamic_keyProps{
+    Context:  nativecontext.ITypiaContext{},
+    Metadata: keyMeta,
+    Input:    input,
+  }) == nil || check_dynamic_key_strict_equal(input, input) == nil ||
+    check_dynamic_key_internal(nativecontext.ITypiaContext{}, "helper") == nil {
+    t.Fatal("dynamic key helper returned nil")
+  }
+  if check_dynamic_key_atomist(nativehelpers.ICheckEntry{
+    Expression: input,
+    Conditions: [][]nativehelpers.ICheckEntry_ICondition{{
+      {Expression: input},
+    }},
+  }) == nil || check_dynamic_key_reduce(nil, shimast.KindBarBarToken) == nil {
+    t.Fatal("dynamic key atomist or reducer returned nil")
+  }
 
-	regularMeta := iterateAtomic("string")
-	optionalMeta := iterateAtomic("string")
-	optionalMeta.Required = false
-	optionalMeta.Optional = true
-	regular := []nativehelpers.IExpressionEntry{
-		{Input: input, Key: iterateLiteral("fixed"), Meta: regularMeta, Expression: input},
-		{Input: input, Key: iterateLiteral("optional"), Meta: optionalMeta, Expression: input},
-	}
-	dynamic := []nativehelpers.IExpressionEntry{
-		{Input: input, Key: keyMeta, Meta: regularMeta, Expression: input},
-	}
-	config := Check_object_IConfig{
-		Equals:    true,
-		Undefined: false,
-		Positive:  factory.NewKeywordExpression(shimast.KindTrueKeyword),
-		Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
-			return factory.NewKeywordExpression(shimast.KindFalseKeyword)
-		},
-	}
-	if Check_dynamic_properties(Check_dynamic_propertiesProps{
-		Config:  config,
-		Context: nativecontext.ITypiaContext{},
-		Regular: regular,
-		Dynamic: dynamic,
-		Input:   input,
-	}) == nil || !check_dynamic_properties_every_required(regular[:1]) ||
-		check_dynamic_properties_internal(nativecontext.ITypiaContext{}, "helper") == nil {
-		t.Fatal("dynamic properties helper returned unexpected result")
-	}
+  regularMeta := iterateAtomic("string")
+  optionalMeta := iterateAtomic("string")
+  optionalMeta.Required = false
+  optionalMeta.Optional = true
+  regular := []nativehelpers.IExpressionEntry{
+    {Input: input, Key: iterateLiteral("fixed"), Meta: regularMeta, Expression: input},
+    {Input: input, Key: iterateLiteral("optional"), Meta: optionalMeta, Expression: input},
+  }
+  dynamic := []nativehelpers.IExpressionEntry{
+    {Input: input, Key: keyMeta, Meta: regularMeta, Expression: input},
+  }
+  config := Check_object_IConfig{
+    Equals:    true,
+    Undefined: false,
+    Positive:  factory.NewKeywordExpression(shimast.KindTrueKeyword),
+    Superfluous: func(value *shimast.Expression, description *shimast.Expression) *shimast.Node {
+      return factory.NewKeywordExpression(shimast.KindFalseKeyword)
+    },
+  }
+  if Check_dynamic_properties(Check_dynamic_propertiesProps{
+    Config:  config,
+    Context: nativecontext.ITypiaContext{},
+    Regular: regular,
+    Dynamic: dynamic,
+    Input:   input,
+  }) == nil || !check_dynamic_properties_every_required(regular[:1]) ||
+    check_dynamic_properties_internal(nativecontext.ITypiaContext{}, "helper") == nil {
+    t.Fatal("dynamic properties helper returned unexpected result")
+  }
 
-	stringMeta := iterateAtomic("string")
-	array := iterateCheckArray("string[]", stringMeta)
-	tuple := iterateCheckTuple("[string]", stringMeta)
-	unionConfig := Check_union_array_like_IConfig{
-		Checker: func(props Check_union_array_like_CheckerProps) *shimast.Node { return input },
-		Decoder: func(props Check_union_array_like_DecoderProps) *shimast.Node { return props.Input },
-		Empty:   input,
-		Success: factory.NewKeywordExpression(shimast.KindTrueKeyword),
-		Failure: func(props Check_union_array_like_FailureProps) *shimast.Node {
-			if props.Expected == "" {
-				t.Fatal("union failure should include expected names")
-			}
-			return factory.NewReturnStatement(input)
-		},
-	}
-	accessor := Check_union_array_like_IAccessor{
-		Transform: func(origin any) any { return origin },
-		Element: func(meta any) any {
-			if arr, ok := meta.(*nativemetadata.MetadataArray); ok {
-				return arr.Type.Value
-			}
-			return meta
-		},
-		Name: func(meta any, elem any) string {
-			switch typed := meta.(type) {
-			case *nativemetadata.MetadataArray:
-				return typed.Type.Name
-			case *nativemetadata.MetadataTuple:
-				return typed.Type.Name
-			default:
-				return "unknown"
-			}
-		},
-		Front: func(input *shimast.Expression) *shimast.Node {
-			return factory.NewElementAccessExpression(input, nil, nativefactories.ExpressionFactory.Number(0), shimast.NodeFlagsNone)
-		},
-		Array: func(input *shimast.Expression) *shimast.Node { return input },
-		Size: func(input *shimast.Expression) *shimast.Node {
-			return nativefactories.IdentifierFactory.Access(emit, input, "length")
-		},
-	}
-	if Check_union_array_like(Check_union_array_likeProps{
-		Config:      unionConfig,
-		Accessor:    accessor,
-		Input:       input,
-		Definitions: []any{tuple, array},
-		Explore:     map[string]any{"source": "test"},
-	}) == nil || check_union_array_like_array_if(func(init string, from *shimast.Expression, statement *shimast.Node) *shimast.Node {
-		return statement
-	}, input, input, factory.NewKeywordExpression(shimast.KindTrueKeyword)) == nil ||
-		check_union_array_like_return_or_statement(input) == nil {
-		t.Fatal("union array-like helper returned nil")
-	}
-	if check_union_array_like_explore(map[string]any{}, true, ".x").(map[string]any)["postfix"] != ".x" ||
-		check_union_array_like_explore_trace(map[string]any{}, true).(map[string]any)["tracable"] != true {
-		t.Fatal("union array-like explore helper mismatch")
-	}
-}
-
-func iterateCheckArray(name string, value *nativemetadata.MetadataSchema) *nativemetadata.MetadataArray {
-	return nativemetadata.MetadataArray_create(nativemetadata.MetadataArray{
-		Type: nativemetadata.MetadataArrayType_create(nativemetadata.MetadataArrayType{
-			Name:      name,
-			Value:     value,
-			Nullables: []bool{},
-		}),
-	})
-}
-
-func iterateCheckTuple(name string, value *nativemetadata.MetadataSchema) *nativemetadata.MetadataTuple {
-	return nativemetadata.MetadataTuple_create(nativemetadata.MetadataTuple{
-		Type: nativemetadata.MetadataTupleType_create(nativemetadata.MetadataTupleType{
-			Name:      name,
-			Elements:  []*nativemetadata.MetadataSchema{value},
-			Nullables: []bool{},
-		}),
-	})
 }