@voxgig/sdkgen 4.8.2 → 4.9.0

package/project/.sdk/tm/go/test/struct_runner_test.go

@@ -1,1094 +0,0 @@
-// Vendored from github.com/voxgig/struct/go/testutil
-// Test runner that uses the test model in build/test.
-
-package sdktest
-
-import (
-	"fmt"
-
-	voxgigstruct "github.com/voxgig/struct"
-
-	"encoding/json"
-	"errors"
-	"os"
-	"path/filepath"
-	"reflect"
-	"regexp"
-	"strings"
-	"testing"
-	"unicode"
-)
-
-// StructClient interface defines the minimum needed to work with the runner
-type StructClient interface {
-	Utility() StructUtilityIF
-}
-
-type StructUtilityIF interface {
-	Struct() *StructUtility
-	Check(ctx map[string]any) map[string]any
-}
-
-type StructUtility struct {
-	IsNode     func(val any) bool
-	Clone      func(val any) any
-	CloneFlags func(val any, flags map[string]bool) any
-	GetPath    func(store any, path any, injdefs ...*voxgigstruct.Injection) any
-	Inject     func(val any, store any, injdefs ...*voxgigstruct.Injection) any
-	Items      func(val any) [][2]any
-	Stringify  func(val any, maxlen ...int) string
-	Walk       func(val any, apply voxgigstruct.WalkApply, opts ...any) any
-
-	DelProp    func(parent any, key any) any
-	EscRe      func(s string) string
-	EscUrl     func(s string) string
-	Filter     func(val any, check func([2]any) bool) []any
-	Flatten    func(list any, depths ...int) any
-	GetDef     func(val any, alt any) any
-	GetElem    func(val any, key any, alts ...any) any
-	GetProp    func(val any, key any, alts ...any) any
-	HasKey     func(val any, key any) bool
-	IsEmpty    func(val any) bool
-	IsFunc     func(val any) bool
-	IsKey      func(val any) bool
-	IsList     func(val any) bool
-	IsMap      func(val any) bool
-	Join       func(arr []any, args ...any) string
-	Jsonify    func(val any, flags ...map[string]any) string
-	KeysOf     func(val any) []string
-	Merge      func(val any, maxdepths ...int) any
-	Pad        func(str any, args ...any) string
-	Pathify    func(val any, from ...int) string
-	Select     func(children any, query any) []any
-	SetPath    func(store any, path any, val any, injdefs ...map[string]any) any
-	SetProp    func(parent any, key any, newval any) any
-	Size       func(val any) int
-	Slice      func(val any, args ...any) any
-	StrKey     func(key any) string
-	Transform  func(data any, spec any, injdefs ...*voxgigstruct.Injection) (any, error)
-	Typify     func(value any) int
-	Typename   func(t int) string
-	Validate   func(data any, spec any, injdefs ...*voxgigstruct.Injection) (any, error)
-
-	SKIP   any
-	DELETE any
-
-	Jm func(kv ...any) map[string]any
-	Jt func(v ...any) []any
-
-	CheckPlacement func(modes int, ijname string, parentTypes int, inj *voxgigstruct.Injection) bool
-	InjectorArgs   func(argTypes []int, args []any) []any
-	InjectChild    func(child any, store any, inj *voxgigstruct.Injection) *voxgigstruct.Injection
-}
-
-type Subject func(args ...any) (any, error)
-
-type RunSet func(
-	t *testing.T,
-	testspec any,
-	testsubject any,
-)
-
-type RunSetFlags func(
-	t *testing.T,
-	testspec any,
-	flags map[string]bool,
-	testsubject any,
-)
-
-type RunPack struct {
-	Spec        map[string]any
-	RunSet      RunSet
-	RunSetFlags RunSetFlags
-	Subject     Subject
-	Client      StructClient
-}
-
-type TestPack struct {
-	Name    string
-	Client  StructClient
-	Subject Subject
-	Utility StructUtilityIF
-}
-
-var (
-	NULLMARK   = "__NULL__"
-	UNDEFMARK  = "__UNDEF__"
-	EXISTSMARK = "__EXISTS__"
-)
-
-// MakeRunner creates a runner function that can be used to run tests
-func MakeRunner(testfile string, client StructClient) func(name string, store any) (*RunPack, error) {
-
-	return func(name string, store any) (*RunPack, error) {
-		utility := client.Utility()
-		structUtil := utility.Struct()
-
-		spec := resolveSpec(name, testfile)
-
-		clients, err := resolveClients(spec, store, structUtil, client)
-		if err != nil {
-			return nil, err
-		}
-
-		subject, err := resolveSubject(name, utility)
-		if err != nil {
-			return nil, err
-		}
-
-		var runsetFlags RunSetFlags = func(
-			t *testing.T,
-			testspec any,
-			flags map[string]bool,
-			testsubject any,
-		) {
-			if testsubject != nil {
-				subject = subjectify(testsubject)
-			}
-
-			flags = resolveFlags(flags)
-
-			var testspecmap = fixJSON(
-				testspec.(map[string]any),
-				flags,
-			).(map[string]any)
-
-			testset, ok := testspecmap["set"].([]any)
-			if !ok {
-				panic(fmt.Sprintf("No test set in %v", name))
-			}
-
-			for _, entryVal := range testset {
-				entry := resolveEntry(entryVal, flags)
-
-				// Go cannot distinguish absent values from nil (JSON null).
-				// Skip entries where "in" or "out" is missing and the expected
-				// result is T_noval, as this represents a concept (undefined)
-				// that does not exist in Go.
-				_, hasIn := entry["in"]
-				_, hasOut := entry["out"]
-				if !hasIn || !hasOut {
-					if outVal, ok := entry["out"]; ok {
-						if outNum, ok := outVal.(int); ok && outNum == voxgigstruct.T_noval {
-							continue
-						}
-					}
-				}
-
-				// When null flag is false, skip entries where in values are nil,
-				// since Go cannot distinguish absent/undefined from nil.
-				if !flags["null"] {
-					if inMap, ok := entry["in"].(map[string]any); ok {
-						skipEntry := false
-						for _, v := range inMap {
-							if v == nil {
-								skipEntry = true
-								break
-							}
-						}
-						if skipEntry {
-							continue
-						}
-					}
-					// Also skip when out is nil (nil/undefined distinction).
-					if entry["out"] == nil {
-						continue
-					}
-				}
-
-				testpack, err := resolveTestPack(name, entry, subject, client, clients)
-				if err != nil {
-					// No debug output
-					return
-				}
-
-				args := resolveArgs(entry, testpack)
-				entry["args"] = args
-
-				res, err := testpack.Subject(args...)
-
-				res = fixJSON(res, flags)
-
-				entry["res"] = res
-				entry["thrown"] = err
-
-				if nil == err {
-					checkResult(t, entry, res, structUtil)
-				} else {
-					handleError(t, entry, err, structUtil)
-				}
-			}
-		}
-
-		var runsetFn RunSet = func(
-			t *testing.T,
-			testspec any,
-			testsubject any,
-		) {
-			runsetFlags(t, testspec, nil, testsubject)
-		}
-
-		return &RunPack{
-			Spec:        spec,
-			RunSet:      runsetFn,
-			RunSetFlags: runsetFlags,
-			Subject:     subject,
-		}, nil
-	}
-}
-
-func resolveSpec(
-	name string,
-	testfile string,
-) map[string]any {
-
-	data, err := os.ReadFile(filepath.Join(".", testfile))
-	if err != nil {
-		panic(err)
-	}
-
-	var alltests map[string]any
-	if err := json.Unmarshal(data, &alltests); err != nil {
-		panic(err)
-	}
-
-	var spec map[string]any
-
-	// Check if there's a "primary" key that is a map, and if it has our 'name'
-	if primaryRaw, hasPrimary := alltests["primary"]; hasPrimary {
-		if primaryMap, ok := primaryRaw.(map[string]any); ok {
-			if found, ok := primaryMap[name]; ok {
-				spec = found.(map[string]any)
-			}
-		}
-	}
-
-	if spec == nil {
-		if found, ok := alltests[name]; ok {
-			spec = found.(map[string]any)
-		}
-	}
-
-	if spec == nil {
-		spec = alltests
-	}
-
-	return spec
-}
-
-func resolveClients(
-	spec map[string]any,
-	store any,
-	structUtil *StructUtility,
-	baseClient StructClient,
-) (map[string]StructClient, error) {
-	clients := make(map[string]StructClient)
-
-	defRaw, hasDef := spec["DEF"]
-	if !hasDef {
-		return clients, nil
-	}
-
-	defMap, ok := defRaw.(map[string]any)
-	if !ok {
-		return clients, nil
-	}
-
-	clientRaw, hasClient := defMap["client"]
-	if !hasClient {
-		return clients, nil
-	}
-
-	clientMap, ok := clientRaw.(map[string]any)
-	if !ok {
-		return clients, nil
-	}
-
-	// Check if the client has a Tester method using reflection
-	baseClientValue := reflect.ValueOf(baseClient)
-	testerMethod := baseClientValue.MethodByName("Tester")
-	if !testerMethod.IsValid() {
-		return clients, nil
-	}
-
-	for _, cdef := range structUtil.Items(clientMap) {
-		key, _ := cdef[0].(string)
-		valMap, _ := cdef[1].(map[string]any)
-
-		if valMap == nil {
-			continue
-		}
-
-		testRaw, _ := valMap["test"].(map[string]any)
-		opts, _ := testRaw["options"].(map[string]any)
-		if opts == nil {
-			opts = make(map[string]any)
-		}
-
-		// Inject store values into options
-		if store != nil && structUtil.Inject != nil {
-			structUtil.Inject(opts, store)
-		}
-
-		// Call the client's Tester method using reflection
-		results := testerMethod.Call([]reflect.Value{reflect.ValueOf(opts)})
-		if len(results) != 2 {
-			return nil, fmt.Errorf("resolveClients: Tester method must return (Client, error)")
-		}
-
-		// Check for error
-		if !results[1].IsNil() {
-			err := results[1].Interface().(error)
-			return nil, err
-		}
-
-		// Get the new client instance
-		newClientValue := results[0].Interface()
-		newClient, ok := newClientValue.(StructClient)
-		if !ok {
-			return nil, fmt.Errorf("resolveClients: Tester method did not return a StructClient")
-		}
-
-		clients[key] = newClient
-	}
-
-	return clients, nil
-}
-
-func resolveSubject(
-	name string,
-	container any,
-) (Subject, error) {
-	name = uppercaseFirstLetter(name)
-
-	val := reflect.ValueOf(container)
-
-	if _, ok := container.(StructUtilityIF); ok {
-		subjectVal := val.MethodByName(name)
-		subjectIF := subjectVal.Interface()
-		subject := subjectify(subjectIF)
-		return subject, nil
-	}
-
-	if val.Kind() == reflect.Ptr {
-		val = val.Elem()
-	}
-	if val.Kind() != reflect.Struct {
-		return nil, errors.New("resolveSubject: not a struct or struct pointer")
-	}
-
-	fieldVal := val.FieldByName(name)
-
-	if !fieldVal.IsValid() {
-		return nil, fmt.Errorf("resolveSubject: field %q is not a func", name)
-	}
-
-	if fieldVal.Kind() != reflect.Func {
-		return nil, fmt.Errorf("resolveSubject: field %q is not a func", name)
-	}
-
-	fn := fieldVal.Interface()
-	var sfn Subject
-
-	sfn, ok := fn.(Subject)
-	if !ok {
-		sfn = subjectify(fn)
-	}
-
-	return sfn, nil
-}
-
-func resolveFlags(flags map[string]bool) map[string]bool {
-
-	if nil == flags {
-		flags = map[string]bool{}
-	}
-
-	if _, ok := flags["null"]; !ok {
-		flags["null"] = true
-	}
-
-	return flags
-}
-
-func resolveEntry(entryVal any, flags map[string]bool) map[string]any {
-	entry := entryVal.(map[string]any)
-
-	if flags["null"] {
-
-		// Where `out` is missing in the test spec, set it to the special null symbol __NULL__
-		_, has := entry["out"]
-		if !has {
-			entry["out"] = NULLMARK
-		}
-	}
-
-	return entry
-}
-
-func checkResult(
-	t *testing.T,
-	entry map[string]any,
-	res any,
-	structUtils *StructUtility,
-) {
-	// Check if this test expects an output or an error
-	_, hasExpectedErr := entry["err"]
-
-	// Special case for array tests
-	if hasExpectedErr && entry["err"] != nil {
-		errStr, isStr := entry["err"].(string)
-		if isStr && strings.Contains(errStr, "null:") {
-			return
-		}
-	}
-
-	if entry["match"] == nil || entry["out"] != nil {
-		var cleanRes any
-		if res != nil {
-			flags := map[string]bool{"func": false}
-			cleanRes = structUtils.CloneFlags(res, flags)
-		} else {
-			cleanRes = res
-		}
-
-		if !reflect.DeepEqual(cleanRes, entry["out"]) {
-			t.Error(outFail(entry, cleanRes, entry["out"]))
-			return
-		}
-	}
-
-	if entry["match"] != nil {
-		pass, err := MatchNode(
-			entry["match"],
-			map[string]any{
-				"in":   entry["in"],
-				"out":  entry["res"],
-				"ctx":  entry["ctx"],
-				"args": entry["args"],
-			},
-			structUtils,
-		)
-		if err != nil {
-			t.Error(fmt.Sprintf("match error: %v", err))
-			return
-		}
-		if !pass {
-			t.Error(fmt.Sprintf("match fail: %v", err))
-			return
-		}
-	}
-}
-
-func outFail(entry any, res any, out any) string {
-	return fmt.Sprintf("Entry:\n%s\nExpected:\n%s\nGot:\n%s\n",
-		inspect(entry), inspect(out), inspect(res))
-}
-
-func inspect(val any) string {
-	return inspectIndent(val, "")
-}
-
-func inspectIndent(val any, indent string) string {
-	result := ""
-
-	switch v := val.(type) {
-	case map[string]any:
-		result += indent + "{\n"
-		for key, value := range v {
-			result += fmt.Sprintf("%s  \"%s\": %s", indent, key, inspectIndent(value, indent+"  "))
-		}
-		result += indent + "}\n"
-
-	case []any:
-		result += indent + "[\n"
-		for _, value := range v {
-			result += fmt.Sprintf("%s  - %s", indent, inspectIndent(value, indent+"  "))
-		}
-		result += indent + "]\n"
-
-	default:
-		result += fmt.Sprintf("%v (%s)\n", v, reflect.TypeOf(v))
-	}
-
-	return result
-}
-
-func handleError(
-	t *testing.T,
-	entry map[string]any,
-	testerr error,
-	structUtils *StructUtility,
-) {
-	// Record the error in the entry
-	entry["thrown"] = testerr
-	entryErr := entry["err"]
-
-	// Special cases for testing
-	if nil == entryErr && entry["out"] != nil {
-		errStr := testerr.Error()
-		if strings.Contains(errStr, "null:") &&
-			strings.Contains(structUtils.Stringify(entry["in"]), "q:[") {
-			return
-		}
-	}
-
-	if nil == entryErr {
-		t.Error(fmt.Sprintf("%s\n\nENTRY: %s", testerr.Error(), structUtils.Stringify(entry)))
-		return
-	}
-
-	boolErr, hasBoolErr := entryErr.(bool)
-	if hasBoolErr && !boolErr {
-		t.Error(fmt.Sprintf("%s\n\nENTRY: %s", testerr.Error(), structUtils.Stringify(entry)))
-		return
-	}
-
-	// Handle special cases
-	errStr := testerr.Error()
-	entryErrStr, isStr := entryErr.(string)
-	if isStr {
-		if strings.Contains(errStr, "null:") && strings.Contains(entryErrStr, "null:") {
-			return
-		}
-	}
-
-	matchErr, err := MatchNode(entryErr, errStr, structUtils)
-
-	if err != nil {
-		t.Error(fmt.Sprintf("match error: %v", err))
-		return
-	}
-
-	if boolErr || matchErr {
-		if entry["match"] != nil {
-			flags := map[string]bool{"null": true}
-			matchErr, err := MatchNode(
-				entry["match"],
-				map[string]any{
-					"in":  entry["in"],
-					"out": entry["res"],
-					"ctx": entry["ctx"],
-					"err": fixJSON(testerr, flags),
-				},
-				structUtils,
-			)
-
-			if !matchErr {
-				t.Error(fmt.Sprintf("match failed: %v", matchErr))
-			}
-
-			if nil != err {
-				t.Error(fmt.Sprintf("match failed: %v", err))
-			}
-		}
-
-	} else {
-		t.Error(fmt.Sprintf("ERROR MATCH: [%s] <=> [%s]",
-			structUtils.Stringify(entryErr),
-			errStr,
-		))
-	}
-}
-
-func resolveArgs(entry map[string]any, testpack TestPack) []any {
-	structUtils := testpack.Utility.Struct()
-
-	var args []any
-	if inVal, ok := entry["in"]; ok {
-		args = []any{structUtils.Clone(inVal)}
-	} else {
-		args = []any{}
-	}
-
-	if ctx, exists := entry["ctx"]; exists && ctx != nil {
-		args = []any{ctx}
-	} else if rawArgs, exists := entry["args"]; exists && rawArgs != nil {
-		if slice, ok := rawArgs.([]any); ok {
-			args = slice
-		}
-	}
-
-	if entry["ctx"] != nil || entry["args"] != nil {
-		if len(args) > 0 {
-			first := args[0]
-			if firstMap, ok := first.(map[string]any); ok && first != nil {
-				clonedFirst := structUtils.Clone(firstMap)
-				args[0] = clonedFirst
-				entry["ctx"] = clonedFirst
-				if m, ok := clonedFirst.(map[string]any); ok {
-					m["client"] = testpack.Client
-					m["utility"] = testpack.Utility
-				}
-			}
-		}
-	}
-
-	return args
-}
-
-func resolveTestPack(
-	name string,
-	entry any,
-	testsubject any,
-	client StructClient,
-	clients map[string]StructClient,
-) (TestPack, error) {
-
-	subject, ok := testsubject.(Subject)
-	if !ok {
-		panic("Bad subject")
-	}
-
-	testpack := TestPack{
-		Name:    name,
-		Client:  client,
-		Subject: subject,
-		Utility: client.Utility(),
-	}
-
-	var err error
-
-	if e, ok := entry.(map[string]any); ok {
-		if rawClient, exists := e["client"]; exists {
-			if clientKey, ok := rawClient.(string); ok {
-				if cl, found := clients[clientKey]; found {
-					testpack.Client = cl
-					testpack.Utility = cl.Utility()
-					testpack.Subject, err = resolveSubject(name, testpack.Utility.Struct())
-				}
-			}
-		}
-	}
-
-	return testpack, err
-}
-
-func MatchNode(
-	check any,
-	base any,
-	structUtil *StructUtility,
-) (bool, error) {
-	pass := true
-	var err error = nil
-
-	// Clone the base object to avoid modifying the original
-	base = structUtil.Clone(base)
-
-	structUtil.Walk(
-		check,
-		func(key *string, val any, _parent any, path []string) any {
-			scalar := !structUtil.IsNode(val)
-
-			if scalar {
-				baseval := structUtil.GetPath(base, path)
-				if !MatchScalar(val, baseval, structUtil) {
-					pass = false
-					err = fmt.Errorf(
-						"MATCHX: %s: [%s] <=> [%s]",
-						strings.Join(path, "."),
-						structUtil.Stringify(val),
-						structUtil.Stringify(baseval),
-					)
-				}
-			}
-			return val
-		},
-	)
-
-	return pass, err
-}
-
-func MatchScalar(check, base any, structUtil *StructUtility) bool {
-	// Handle special cases for undefined and null values
-	if s, ok := check.(string); ok && s == UNDEFMARK {
-		return base == nil || reflect.ValueOf(base).IsZero()
-	}
-
-	// Handle EXISTSMARK - value exists and is not undefined
-	if s, ok := check.(string); ok && s == EXISTSMARK {
-		return base != nil
-	}
-
-	pass := (check == base)
-
-	if !pass {
-		if checkStr, ok := check.(string); ok {
-			basestr := structUtil.Stringify(base)
-
-			if len(checkStr) > 2 && checkStr[0] == '/' && checkStr[len(checkStr)-1] == '/' {
-				pat := checkStr[1 : len(checkStr)-1]
-				if rx, err := regexp.Compile(pat); err == nil {
-					pass = rx.MatchString(basestr)
-				} else {
-					pass = false
-				}
-			} else {
-				basenorm := strings.ToLower(basestr)
-				checknorm := strings.ToLower(structUtil.Stringify(checkStr))
-				pass = strings.Contains(
-					basenorm,
-					checknorm,
-				)
-			}
-		} else {
-			cv := reflect.ValueOf(check)
-			isf := cv.Kind() == reflect.Func
-			if isf {
-				pass = true
-			}
-		}
-	}
-
-	return pass
-}
-
-func subjectify(fn any) Subject {
-	v := reflect.ValueOf(fn)
-	if v.Kind() != reflect.Func {
-		panic("subjectify: not a function")
-	}
-
-	sfn, ok := v.Interface().(Subject)
-	if ok {
-		return sfn
-	}
-
-	fnType := v.Type()
-
-	return func(args ...any) (any, error) {
-
-		argCount := fnType.NumIn()
-
-		if len(args) < argCount {
-			extended := make([]any, argCount)
-			copy(extended, args)
-			args = extended
-		}
-
-		// Build reflect.Value slice for call
-		in := make([]reflect.Value, fnType.NumIn())
-		for i := 0; i < fnType.NumIn(); i++ {
-			paramType := fnType.In(i)
-			arg := args[i]
-
-			if arg == nil {
-				in[i] = reflect.Zero(paramType)
-			} else {
-				val := reflect.ValueOf(arg)
-
-				// Check compatibility so we don't panic on invalid type
-				if !val.Type().AssignableTo(paramType) {
-					return nil, fmt.Errorf(
-						"subjectify: argument %d type %T not assignable to parameter type %s",
-						i, arg, paramType,
-					)
-				}
-				in[i] = val
-			}
-		}
-
-		// Call the original function
-		out := v.Call(in)
-
-		// Interpret results
-		switch len(out) {
-		case 0:
-			return nil, nil
-		case 1:
-			return out[0].Interface(), nil
-		case 2:
-			errVal := out[1].Interface()
-			var err error
-			if errVal != nil {
-				err = errVal.(error)
-			}
-			return out[0].Interface(), err
-		default:
-			return nil, fmt.Errorf("subjectify: function returns too many values (%d)", len(out))
-		}
-	}
-}
-
-func fixJSON(data any, flags map[string]bool) any {
-	// Ensure flags is initialized
-	if flags == nil {
-		flags = map[string]bool{"null": true}
-	}
-
-	// Handle nil data
-	if nil == data && flags["null"] {
-		return NULLMARK
-	}
-
-	// Handle error objects specially
-	if err, ok := data.(error); ok {
-		errorMap := map[string]any{
-			"name":    reflect.TypeOf(err).String(),
-			"message": err.Error(),
-		}
-		return errorMap
-	}
-
-	v := reflect.ValueOf(data)
-
-	switch v.Kind() {
-	case reflect.Float64:
-		if v.Float() == float64(int(v.Float())) {
-			return int(v.Float())
-		}
-		return data
-
-	case reflect.Map:
-		fixedMap := make(map[string]any)
-		for _, key := range v.MapKeys() {
-			strKey, ok := key.Interface().(string)
-			if ok {
-				value := v.MapIndex(key).Interface()
-				if value == nil && flags["null"] {
-					fixedMap[strKey] = NULLMARK
-				} else {
-					fixedMap[strKey] = fixJSON(value, flags)
-				}
-			}
-		}
-		return fixedMap
-
-	case reflect.Slice:
-		length := v.Len()
-		fixedSlice := make([]any, length)
-		for i := 0; i < length; i++ {
-			value := v.Index(i).Interface()
-			if value == nil && flags["null"] {
-				fixedSlice[i] = NULLMARK
-			} else {
-				fixedSlice[i] = fixJSON(value, flags)
-			}
-		}
-		return fixedSlice
-
-	case reflect.Array:
-		length := v.Len()
-		fixedSlice := make([]any, length)
-		for i := 0; i < length; i++ {
-			value := v.Index(i).Interface()
-			if value == nil && flags["null"] {
-				fixedSlice[i] = NULLMARK
-			} else {
-				fixedSlice[i] = fixJSON(value, flags)
-			}
-		}
-		return fixedSlice
-
-	default:
-		return data
-	}
-}
-
-func NullModifier(
-	val any,
-	key any,
-	parent any,
-	inj *voxgigstruct.Injection,
-	store any,
-) {
-	switch v := val.(type) {
-	case string:
-		if NULLMARK == v {
-			_ = voxgigstruct.SetProp(parent, key, nil)
-		} else if UNDEFMARK == v {
-			_ = voxgigstruct.SetProp(parent, key, nil)
-		} else if EXISTSMARK == v {
-			// For EXISTSMARK, no transform needed
-		} else {
-			_ = voxgigstruct.SetProp(parent, key,
-				strings.ReplaceAll(v, NULLMARK, "null"))
-		}
-	}
-}
-
-func Fdt(data any) string {
-	return fdti(data, "")
-}
-
-func fdti(data any, indent string) string {
-	result := ""
-
-	switch v := data.(type) {
-	case map[string]any:
-		result += indent + "{\n"
-		for key, value := range v {
-			result += fmt.Sprintf("%s  \"%s\": %s", indent, key, fdti(value, indent+"  "))
-		}
-		result += indent + "}\n"
-
-	case []any:
-		result += indent + "[\n"
-		for _, value := range v {
-			result += fmt.Sprintf("%s  - %s", indent, fdti(value, indent+"  "))
-		}
-		result += indent + "]\n"
-
-	default:
-		result += fmt.Sprintf("%v (%s)\n", v, reflect.TypeOf(v))
-	}
-
-	return result
-}
-
-func ToJSONString(data any) string {
-	jsonBytes, err := json.Marshal(data)
-	if err != nil {
-		return ""
-	}
-	return string(jsonBytes)
-}
-
-func uppercaseFirstLetter(s string) string {
-	if len(s) == 0 {
-		return s
-	}
-
-	runes := []rune(s)
-	runes[0] = unicode.ToUpper(runes[0])
-	return string(runes)
-}
-
-// StructSDK is the test SDK client for the struct runner
-type StructSDK struct {
-	opts    map[string]any
-	utility *StructSDKUtility
-}
-
-// StructSDKUtility implements the StructUtilityIF interface
-type StructSDKUtility struct {
-	sdk     *StructSDK
-	structu *StructUtility
-}
-
-// Struct returns the StructUtility
-func (u *StructSDKUtility) Struct() *StructUtility {
-	return u.structu
-}
-
-// Contextify implements the contextify function
-func (u *StructSDKUtility) Contextify(ctxmap map[string]any) map[string]any {
-	return ctxmap
-}
-
-// Check implements the check function
-func (u *StructSDKUtility) Check(ctx map[string]any) map[string]any {
-	zed := "ZED"
-	if u.sdk.opts != nil {
-		if foo, ok := u.sdk.opts["foo"]; ok && foo != nil {
-			zed += fmt.Sprint(foo)
-		}
-	}
-	zed += "_"
-
-	if ctx == nil {
-		zed += "0"
-	} else if meta, ok := ctx["meta"].(map[string]any); ok && meta != nil {
-		if bar, ok := meta["bar"]; ok && bar != nil {
-			zed += fmt.Sprint(bar)
-		} else {
-			zed += "0"
-		}
-	} else {
-		zed += "0"
-	}
-
-	return map[string]any{
-		"zed": zed,
-	}
-}
-
-// NewStructSDK creates a new StructSDK instance with the given options
-func NewStructSDK(opts map[string]any) *StructSDK {
-	if opts == nil {
-		opts = map[string]any{}
-	}
-
-	sdk := &StructSDK{
-		opts: opts,
-	}
-
-	// Create the StructUtility
-	structUtil := &StructUtility{
-		IsNode:     voxgigstruct.IsNode,
-		Clone:      voxgigstruct.Clone,
-		CloneFlags: voxgigstruct.CloneFlags,
-		GetPath:    voxgigstruct.GetPath,
-		Inject:     voxgigstruct.Inject,
-		Items:      voxgigstruct.Items,
-		Stringify:  voxgigstruct.Stringify,
-		Walk:       voxgigstruct.Walk,
-
-		DelProp:    voxgigstruct.DelProp,
-		EscRe:      voxgigstruct.EscRe,
-		EscUrl:     voxgigstruct.EscUrl,
-		Filter:     voxgigstruct.Filter,
-		Flatten:    voxgigstruct.Flatten,
-		GetDef:     voxgigstruct.GetDef,
-		GetElem:    voxgigstruct.GetElem,
-		GetProp:    voxgigstruct.GetProp,
-		HasKey:     voxgigstruct.HasKey,
-		IsEmpty:    voxgigstruct.IsEmpty,
-		IsFunc:     voxgigstruct.IsFunc,
-		IsKey:      voxgigstruct.IsKey,
-		IsList:     voxgigstruct.IsList,
-		IsMap:      voxgigstruct.IsMap,
-		Join:       voxgigstruct.Join,
-		Jsonify:    voxgigstruct.Jsonify,
-		KeysOf:     voxgigstruct.KeysOf,
-		Merge:      voxgigstruct.Merge,
-		Pad:        voxgigstruct.Pad,
-		Pathify:    voxgigstruct.Pathify,
-		Select:     voxgigstruct.Select,
-		SetPath:    voxgigstruct.SetPath,
-		SetProp:    voxgigstruct.SetProp,
-		Size:       voxgigstruct.Size,
-		Slice:      voxgigstruct.Slice,
-		StrKey:     voxgigstruct.StrKey,
-		Transform:  voxgigstruct.Transform,
-		Typify:     voxgigstruct.Typify,
-		Typename:   voxgigstruct.Typename,
-		Validate:   voxgigstruct.Validate,
-
-		SKIP:   voxgigstruct.SKIP,
-		DELETE: voxgigstruct.DELETE,
-
-		Jm: voxgigstruct.Jm,
-		Jt: voxgigstruct.Jt,
-
-		CheckPlacement: voxgigstruct.CheckPlacement,
-		InjectorArgs:   voxgigstruct.InjectorArgs,
-		InjectChild:    voxgigstruct.InjectChild,
-	}
-
-	// Create the utility
-	sdk.utility = &StructSDKUtility{
-		sdk:     sdk,
-		structu: structUtil,
-	}
-
-	return sdk
-}
-
-// MakeTestStructSDK creates a new StructSDK instance for testing
-func MakeTestStructSDK(opts map[string]any) (*StructSDK, error) {
-	return NewStructSDK(opts), nil
-}
-
-// Tester creates a new StructSDK instance with options or default options
-func (s *StructSDK) Tester(opts map[string]any) (*StructSDK, error) {
-	if opts == nil {
-		opts = s.opts
-	}
-	return NewStructSDK(opts), nil
-}
-
-// Utility returns the utility object
-func (s *StructSDK) Utility() StructUtilityIF {
-	return s.utility
-}