}

func structToUnstructured(sv, dv reflect.Value) error {
	st, dt := sv.Type(), dv.Type()
	if dt.Kind() == reflect.Interface && dv.NumMethod() == 0 {
		dv.Set(reflect.MakeMapWithSize(mapStringInterfaceType, st.NumField()))
		dv = dv.Elem()
		dt = dv.Type()
	}
	if dt.Kind() != reflect.Map {
		return fmt.Errorf("cannot convert struct to: %v", dt.Kind())
	}
	realMap := dv.Interface().(map[string]interface{})

    def setup() {
        settingsFile '''
            pluginManagement {
                includeBuild("dv-conventions")
            }
            plugins {
                id("dv-conventions")
            }
        '''

        buildFile '''
            plugins { id("java") }
        '''
    }

    @NotYetImplemented

platforms/core-execution/build-cache/                       @gradle/bt-execution @gradle/bt-dv-build-cache
platforms/core-execution/build-cache-base/                  @gradle/bt-execution @gradle/bt-dv-build-cache
platforms/core-execution/build-cache-http/                  @gradle/bt-execution @gradle/bt-dv-build-cache
platforms/core-execution/build-cache-packaging/             @gradle/bt-execution @gradle/bt-dv-build-cache

		sv = reflect.ValueOf(src)
	}

	dv := reflect.Indirect(dpv)
	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
		switch b := src.(type) {
		case []byte:
			dv.Set(reflect.ValueOf(bytes.Clone(b)))
		default:
			dv.Set(sv)
		}
		return nil
	}

	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
		dv.Set(sv.Convert(dv.Type()))
		return nil
	}

// ExprValue converts the DynValue into a CEL value.
func (dv *DynValue) ExprValue() ref.Val {
	return dv.exprValue
}

// Value returns the underlying value held by this reference.
func (dv *DynValue) Value() interface{} {
	return dv.value
}

// SetValue updates the underlying value held by this reference.
func (dv *DynValue) SetValue(value interface{}) error {
	dv.value = value
	var err error

		NewObjectValue(NewObjectType("TestObject", map[string]*DeclField{})),
	}
	for i, v := range vals {
		dv := testValue(t, int64(i), v)
		if dv.Equal(dv.ExprValue()) != types.True {
			t.Errorf("got %v, wanted dyn value %v equal to itself", dv.Equal(dv.ExprValue()), dv.ExprValue())
		}
	}
}

func TestListValueAdd(t *testing.T) {
	lv := NewListValue()
	lv.Append(testValue(t, 1, "first"))

	}

	found := false
	for i, dv := range ssv.DecodableVersions {
		if errs := isValidAPIVersion(dv); len(errs) > 0 {
			allErrs = append(allErrs, field.Invalid(fldPath.Child("decodableVersions").Index(i), dv, strings.Join(errs, ",")))
		}
		if dv == ssv.EncodingVersion {
			found = true
		}
	}
	if !found {

		t.Errorf("got %v, wanted CEL map type", expT)
	}
}

func testValue(t *testing.T, id int64, val interface{}) *DynValue {
	t.Helper()
	dv, err := NewDynValue(id, val)
	if err != nil {
		t.Fatalf("NewDynValue(%d, %v) failed: %v", id, val, err)
	}
	return dv

	}
}

func testValue(t *testing.T, id int64, val interface{}) *apiservercel.DynValue {
	t.Helper()
	dv, err := apiservercel.NewDynValue(id, val)
	if err != nil {
		t.Fatalf("NewDynValue(%d, %v) failed: %v", id, val, err)
	}
	return dv

        DialectVersion selected = null;
        for ( DialectVersion dv : DialectVersion.values() ) {
            if ( !dv.isSMB2() ) {
                continue;
            }
            if ( dv.getDialect() == getDialectRevision() ) {
                selected = dv;
            }
        }

        if ( selected == null ) {