private static final String JVM_VERSION_TOO_HIGH_TEMPLATE = "Dependency resolution is looking for a library compatible with JVM runtime version %s, but '%s' is only compatible with JVM runtime version %s or newer.";

    @Override
    protected JavaVersion getJVMVersion(IncompatibleGraphVariantFailure failure) {

    }

    private String suggestUpdateJVM(JavaVersion minRequiredJVMVersion) {
        return "Run this build using a Java " + minRequiredJVMVersion.getMajorVersion() + " or newer JVM.";
    }

	variablesMap.Append("dict", func(_ *MapValue) ref.Val {
		evalCounter++
		v, err := compileAndRun(env, activation, `{"a": "a"}`)
		if err != nil {
			return types.NewErr(err.Error())
		}
		return v
	})

	// iterate the map with .all
	exp = `variables.all(n, n != "")`
	v, err = compileAndRun(env, activation, exp)
	if err != nil {
		t.Fatalf("%q: %v", exp, err)
	}

		}
	} else {
		fmt.Fprintf(buf, "%s%s\n", prefix1, b.Fence)
		for _, line := range b.Text {
			fmt.Fprintf(buf, "%s%s\n", s.prefix, line)
		}
		fmt.Fprintf(buf, "%s%s\n", s.prefix, b.Fence)
	}
}

func newPre(p *parseState, s line) (line, bool) {
	peek2 := s
	if p.para() == nil && peek2.trimSpace(4, 4, false) && !peek2.isBlank() {
		b := &preBuilder{ /*indent: strings.TrimSuffix(s.string(), peek2.string())*/ }
		p.addBlock(b)

func (v *ObjectVal) ConvertToType(typeValue ref.Type) ref.Val {
	switch typeValue {
	case v.typeRef:
		return v
	case types.TypeType:
		return v.typeRef.CELType()
	}
	return types.NewErr("unsupported conversion into %v", typeValue)
}

// Equal returns true if the `other` value has the same type and content as the implementing struct.
func (v *ObjectVal) Equal(other ref.Val) ref.Val {

  "reinvocationPolicy" .Values.sidecarInjectorWebhook.reinvocationPolicy
  "namespace" .Release.Namespace }}
{{- define "core" }}
{{- /* Kubernetes unfortunately requires a unique name for the webhook in some newer versions, so we assign
a unique prefix to each. */}}
- name: {{.Prefix}}sidecar-injector.istio.io
  clientConfig:
    {{- if .injectionURL }}
    url: "{{ .injectionURL }}"
    {{- else }}
    service:

     *
     * <p>Consumer compatibility: This method is used by all consumer versions from 2.1-rc-1 to 4.3. It is also used by later consumers when the provider does not
     * implement newer interfaces.
     * </p>
     * <p>Provider compatibility: This method is implemented by all provider versions from 2.1-rc-1.</p>
     *
     * @throws BuildExceptionVersion1 On build failure.

			}
			pre = "-" + pre
		}
	}
	vStr := fmt.Sprintf("v%d.%d.%d%s", v.Major(), v.Minor(), patch, pre)
	return vStr, nil
}

// Validate if the remote version is one Minor release newer than the client version.
// This is done to conform with "stable-X" and only allow remote versions from
// the same Patch level release.
func validateStableVersion(remoteVersion, clientVersion string) (string, error) {

			if newObj == nil {
				return
			}
			if onlyIncludeSpecChanges && oldObj.GetResourceVersion() == newObj.GetResourceVersion() {
				return
			}
			newer := filter(newObj)
			older := filter(oldObj)
			if !newer && !older {
				return
			}
			handler(newObj)
		},
		DeleteFunc: single,
	}
}

// Extract pulls a T from obj, handling tombstones.

                }
            }
        '''
        file('src/test/groovy/MyPluginTest.groovy') << pluginTest()

        then:
        succeeds 'test'
    }

    @Issue("GRADLE-3525")
    def "can use newer Servlet API"() {
        when:
        buildFile << testablePluginProject()


        buildFile << """
            dependencies {
                testImplementation "javax.servlet:javax.servlet-api:3.1.0"