h.fromsvc <- err
	}()

	// Wait for the first signal from the service handler.
	err = <-h.fromsvc
	if err != nil {
		return err
	}
	klog.Infof("Running %s as a Windows service!", serviceName)
	return nil
}

func (h *handler) Execute(_ []string, r <-chan svc.ChangeRequest, s chan<- svc.Status) (bool, uint32) {
	s <- svc.Status{State: svc.StartPending, Accepts: 0}
	// Unblock initService()
	h.fromsvc <- nil

		panic("unknown kind: " + g.String())
	}
	return r
}

// FromGVR converts a GVR to a GVK.
func FromGVR(g schema.GroupVersionResource) (config.GroupVersionKind, bool) {
	switch g {
{{- range .Entries }}
		case gvr.{{.Resource.Identifier}}:
			return {{.Resource.Identifier}}, true
{{- end }}
	}

	return config.GroupVersionKind{}, false
}

// FromGVR converts a GVR to a GVK, and panics if it cannot be converted

! go build ./baddep
stderr golang.org[/\\]notx[/\\]useinternal
stderr 'use of internal package golang.org/x/.* not allowed'

# Internal packages in the standard library should not leak into modules.
go get ./fromstd
! go build ./fromstd
stderr 'use of internal package internal/testenv not allowed'

# Dependencies should be able to use their own internal modules...
go mod edit -module=golang.org/notx
go get ./throughdep

	fromGVK := in.GetObjectKind().GroupVersionKind()
	toGVK, ok := target.KindForGroupVersionKinds([]schema.GroupVersionKind{fromGVK})
	if !ok {
		// TODO: should this be a typed error?
		return nil, fmt.Errorf("%v is unstructured and is not suitable for converting to %q", fromGVK.String(), target)
	}

            roots.add(toSpec(sourceTree))
        }
    }

    private
    fun fromSpec(spec: FileTreeSpec): FileTreeInternal = when (spec) {
        is AdaptedFileTreeSpec -> fileCollectionFactory.treeOf(spec.tree)
        is FilteredFileTreeSpec -> spec.tree.matching(spec.patterns)
        is FilteredMinimalFileTreeSpec -> fromSpec(spec.tree).matching(spec.patterns)
        is WrappedFileCollectionTreeSpec -> spec.collection.asFileTree

        }
    }

    protected static int[] parseTime(final String time) {
        final String[] froms = time.split(":");
        if (froms.length != 2) {
            throw new FessSystemException("Invalid format: " + time);
        }
        final int[] values = new int[2];
        values[0] = Integer.parseInt(froms[0]);
        if (values[0] < 0 || values[0] > 23) {

	test.SetForTest(t, &features.JwksFetchMode, jwt.Envoy)

	const (
		fooSvc       = "foo"
		extensionSvc = "extension"
		jwksSvc      = "jwks"
	)

	cg = core.NewConfigGenTest(t, core.TestOptions{
		Services: []*model.Service{
			{
				Hostname: fooSvc,
				Attributes: model.ServiceAttributes{
					ExportTo:  sets.New(visibility.Public),
					Namespace: nsName,
				},

	}

	loaded := make(map[uint64]bool)
	any := true
	for any {
		var load []uint64
		returnAllUndefs := -1
		undefs, froms := ctxt.loader.UndefinedRelocTargets(returnAllUndefs)
		if buildcfg.GOOS == "windows" {
			undefs, froms = pruneUndefsForWindows(ctxt.loader, undefs, froms)
		}
		for k, symIdx := range undefs {
			sname := ctxt.loader.SymName(symIdx)
			if off := armap[sname]; off != 0 && !loaded[off] {

            val collection = files("abc")
            val froms = collection.from
            assert(froms.size == 1)
            assert(froms.first() == "abc")
        """
        file("groovy-dsl/build.gradle") << """
            def collection = files("abc")
            def froms = collection.from
            assert froms.size() == 1
            assert froms.first() == "abc"
        """
        expect:

func MustToGVR(g config.GroupVersionKind) schema.GroupVersionResource {
	r, ok := ToGVR(g)
	if !ok {
		panic("unknown kind: " + g.String())
	}
	return r
}

// FromGVR converts a GVR to a GVK.
func FromGVR(g schema.GroupVersionResource) (config.GroupVersionKind, bool) {
	switch g {
	case gvr.AuthorizationPolicy:
		return AuthorizationPolicy, true
	case gvr.CertificateSigningRequest: