}
        if (failureCollector.getFlakyScenarioBigRegressions() != 0) {
            sb.append(", ").append(failureCollector.getFlakyScenarioBigRegressions()).append(" flaky scenario(s) regressed badly");
        }

        if (failureCollector.getFlakyScenarioSmallRegressions() != 0) {
            sb.append(", ").append(failureCollector.getFlakyScenarioSmallRegressions()).append(" flaky scenarios(s) regressed slightly");

	// LikelyCause
	likelyCauseAPIServer     = "a problem with the Kubernetes API server"
	likelyCauseConfiguration = "an incorrect or badly formatted configuration"
	likelyCauseSoftwareBug   = "an issue with the Istio code"

	// Is the error permanent?
	transiencePermanentForInstall = "If the error occurred immediately after installation, it is likely permanent."

        and:
        def analyzer = daemons
        analyzer.daemons.size() == 1
        analyzer.visible.size() == 0
    }

    def "daemon drops connection when client request is badly formed"() {
        given:
        buildSucceeds()
        def daemon = daemons.daemon
        daemon.assertIdle()

        when:

        fails "components"
        failure.assertHasCause("Exception thrown while executing model rule: Broken#broken")
        failure.assertHasCause("broken")
    }

    def "fails when @ComponentType registration is badly formed"() {
        buildFile << """
            @Managed
            interface BrokenComponentSpec extends ComponentSpec {
            }

            class Broken extends RuleSource {

			cfgPath:         testUpgradeDiffConfig,
			setManifestPath: true,
			manifestPath:    "bad-path",
			expectedError:   true,
		},
		{
			name:          "invalid: badly formatted version as argument",
			cfgPath:       testUpgradeDiffConfig,
			args:          []string{"bad-version"},
			expectedError: true,
		},
	}

	for _, tc := range testCases {

    public final void transform(File destination) {
        resultBuilder().accept(destination, builder -> {
            try {
                visitEntries(builder);
            } catch (FileException e) {
                // Badly formed archive, so discard the contents and produce an empty JAR
                LOGGER.debug("Malformed archive '{}'. Discarding contents.", source.getName(), e);
            }
        });
    }

		panic("cipher.NewGCM failed: " + err.Error())
	}
	ciphertext, _ := hex.DecodeString("00112233445566")
	plaintext, err := aead.Open(nil, zeroNonce[:], ciphertext, nil)
	if err != nil {
		// The RSA ciphertext was badly formed; the decryption will
		// fail here because the AES-GCM key will be incorrect.
		fmt.Fprintf(os.Stderr, "Error decrypting: %s\n", err)
		return
	}

	fmt.Printf("Plaintext: %s\n", plaintext)
}

            analyzeArtifact(artifact, superTypes, dependencies);
            writeOutput(artifact, outputs, superTypes, dependencies);
        } catch (IOException | FileException ignored) {
            // We support badly formatted jars on the build classpath
            // see: https://github.com/gradle/gradle/issues/13816
            writeOutput(artifact, outputs, Collections.emptyMap(), Collections.emptySet());
        }
    }

	return nil
}

func validateGatewayName(path util.Path, val any) (errs util.Errors) {
	v := val.([]*v1alpha1.GatewaySpec)
	for _, n := range v {
		if n == nil {
			errs = append(errs, util.NewErrs(errors.New("badly formatted gateway configuration")))
		} else {
			errs = append(errs, validateWithRegex(path, n.Name, ObjectNameRegexp)...)
		}
	}
	return

    private static void checkEdge(MetadataGraphEdge e) throws MetadataResolutionException {
        if (e == null) {
            throw new MetadataResolutionException("badly formed edge");
        }
    }
    // ------------------------------------------------------------------------
    public List<MetadataGraphEdge> getEdgesBetween(MetadataGraphVertex vFrom, MetadataGraphVertex vTo) {