}

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
	}

	}

	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 {

    public interface Details {

        /**
         * This method is not called on the Develocity side, at least in DV plugin >= 3.0.
         *
         * @return An empty string.
         *
         * @deprecated This method will be removed in Gradle 9.0
         */
        @Deprecated
        String getConfigurationPath();

import static org.gradle.performance.fixture.BaselineVersionResolver.toBaselineVersions

class AbstractBuildScanPluginPerformanceTest extends AbstractPerformanceTest {

    /**
     * System property that points to a directory with DV plugin information
     * such files containing build commit ID and plugin version.
     */
    private static final INFO_DIR_SYSTEM_PROP = "org.gradle.performance.develocity.plugin.infoDir"

            this.key = key;
            // We need to calculate the size eagerly here, since the file will already be gone
            // (aka in the local cache), when the DV plugin queries the value.
            this.archiveSize = file.length();
        }

        @Override
        public String getCacheKey() {
            return key.getHashCode();
        }

bo: བོད་ཡིག
br: brezhoneg
bs: bosanski jezik
ca: Català
ce: нохчийн мотт
ch: Chamoru
co: corsu
cr: ᓀᐦᐃᔭᐍᐏᐣ
cs: čeština
cu: ѩзыкъ словѣньскъ
cv: чӑваш чӗлхи
cy: Cymraeg
da: dansk
de: Deutsch
dv: Dhivehi
dz: རྫོང་ཁ
ee: Eʋegbe
el: Ελληνικά
en: English
eo: Esperanto
es: español
et: eesti
eu: euskara
fa: فارسی
ff: Fulfulde
fi: suomi
fj: Vakaviti
fo: føroyskt
fr: français
fy: Frysk

// there isn't such an edge one is created.
func (n *Node) AddToEdgeDiv(to *Node, dv, v int64, residual, inline bool) {
	if e := n.Out.FindTo(to); e != nil {
		e.WeightDiv += dv
		e.Weight += v
		if residual {
			e.Residual = true
		}
		if !inline {
			e.Inline = false
		}
		return
	}

	info := &Edge{Src: n, Dest: to, WeightDiv: dv, Weight: v, Residual: residual, Inline: inline}
	n.Out.Add(info)
	to.In.Add(info)