iopsString, iops, err := GenIOPFromProfile(profile, fy, setFlags, force, false, client, l)
	if err != nil {
		return "", nil, err
	}

	errs, warning := validation.ValidateConfig(false, iops.Spec)
	if warning != "" {
		l.LogAndError(warning)
	}

	if errs.ToError() != nil {
		return "", nil, fmt.Errorf("generated config failed semantic validation: %v", errs)
	}
	return iopsString, iops, nil
}

        file("build/reports/checkstyle/main.html").assertContents(containsClass("org.gradle.class2"))
    }

    def "can fail on maximum number of warnings"() {
        given:
        writeConfigFileWithWarnings()
        badCode()

        when:
        buildFile << """
            checkstyle {
                maxWarnings = 1
            }

			expectedRegexp: regexp.MustCompile(`.*key ".*" already set`),
			wantError:      true,
		},
		{
			name: "warning",
			args: []string{"--filename", warningFilename},
			expectedRegexp: regexp.MustCompile(`(?m)".*" has warnings: 
	\* DestinationRule//reviews-cb-policy: outlier detection consecutive errors is deprecated, use consecutiveGatewayErrors or consecutive5xxErrors instead

# Same service as cluster2, should not report warning.
apiVersion: v1
kind: Service
metadata:
  name: my-service
  namespace: my-namespace
spec:
  selector:
    app: my-service
  ports:
  - name: tcp-foo
    protocol: TCP
    port: 8080
    targetPort: 8080
---
# Service with extra port in cluster2, should generate warning.
apiVersion: v1
kind: Service
metadata:
  name: extra-port
  namespace: my-namespace
spec:

			),
		)
	}

	warnings = append(warnings, GetWarningsForPersistentVolumeClaimSpec(field.NewPath("spec"), pv.Spec)...)

	return warnings
}

func GetWarningsForPersistentVolumeClaimSpec(fieldPath *field.Path, pvSpec core.PersistentVolumeClaimSpec) []string {

	var warnings []string
	requestValue := pvSpec.Resources.Requests[core.ResourceStorage]
	if requestValue.MilliValue()%int64(1000) != int64(0) {

        when:
        logger.warning("before")

        then:
        0 * listener._

        when:
        loggingManager.levelInternal = LogLevel.WARN
        loggingManager.start()
        logger.info("ignored")
        logger.warning("warning")

        then:
        1 * listener.onOutput('warning')
        1 * listener.onOutput(SystemProperties.instance.lineSeparator)

wait

# First execute without GOCOVERDIR set...
env GOCOVERDIR=
exec ./example.exe normal
stderr '^warning: GOCOVERDIR not set, no coverage data emitted'

# ... then with GOCOVERDIR set.
env GOCOVERDIR=data/normal
exec ./example.exe normal
! stderr '^warning: GOCOVERDIR not set, no coverage data emitted'
go tool covdata percent -i=data/normal
stdout  'coverage:.*[1-9][0-9.]+%'

}

// WarningsOnCreate returns warnings for the creation of the given object.
func (deploymentStrategy) WarningsOnCreate(ctx context.Context, obj runtime.Object) []string {
	newDeployment := obj.(*apps.Deployment)
	var warnings []string
	if msgs := utilvalidation.IsDNS1123Label(newDeployment.Name); len(msgs) != 0 {

        boolean useKeyServers
    ) {
        assertInitialized();
        // We need at least one fatal failure: if it's only "warnings" we don't care
        // but of there's a fatal failure AND a warning we want to show both
        doRender(displayName, failuresByArtifact, summaryRenderer, useKeyServers);
        doRender(displayName, failuresByArtifact, htmlRenderer, useKeyServers);

    // notice to self: what was this method supposed to do?
    //
    /**
     * <b>Warning</b>: ignored.
     */
    public void returnComponentLogger(String role) {}

    /**
     * <b>Warning</b>: ignored.
     */
    public void returnComponentLogger(String role, String hint) {}

    /**
     * <b>Warning</b>: ignored (always return <code>0</code>).
     */
    public int getThreshold() {
        return 0;