when:
        zip(file("file2"))

        then:
        def e = thrown(org.gradle.api.tasks.bundling.internal.Zip64RequiredException)
        e.message == "xyz\n\nTo build this archive, please enable the zip64 extension.\nSee: doc url"
    }

    void wrapsFailureToAddElement() {
        given:
        Throwable failure = new RuntimeException("broken")

// func with that string and an exit code.
func checkErr(err error, handleErr func(string, int)) {
	if err == nil {
		return
	}

	msg := fmt.Sprintf("%s\nTo see the stack trace of this error execute with --v=5 or higher", err.Error())
	// check if the verbosity level in klog is high enough and print a stack trace.
	f := flag.CommandLine.Lookup("v")
	if f != nil {

        } catch (Exception e) {
            if (e.getCause() instanceof Zip64RequiredException) {
                throw new org.gradle.api.tasks.bundling.internal.Zip64RequiredException(
                    String.format("%s\n\nTo build this archive, please enable the zip64 extension.\nSee: %s", e.getCause().getMessage(), documentationRegistry.getDslRefForProperty(Zip.class, "zip64"))
                );
            }
            zipFile.delete();

	return fmt.Sprintf("Expected path %s with value \n\n%v\nto be a subset of \n\n%v", pv.path, pv.value, util.ToYAML(node))
}

// NegatedFailureMessage implements the Matcher interface.
func (m *HavePathValueContainMatcher) NegatedFailureMessage(actual any) string {
	pv := m.expected.(PathValue)
	node := actual.(map[string]any)
	return fmt.Sprintf("Expected path %s with value \n\n%v\nto NOT be a subset of \n\n%v", pv.path, pv.value, util.ToYAML(node))

            initialApiClassBytes,
            equalTo(changedApiClassBytes)
        )
    }

    fun assertApiChanged() {
        assertThat(
            "expected\n${initialClass.sourceContent}\nto have different API from:\n${changedClass.sourceContent}",
            initialApiClassBytes,
            not(equalTo(changedApiClassBytes))
        )
    }

    private

	var l []ir.Node
	l = append(l, ir.NewAssignStmt(base.Pos, nl, n.X))
	l = append(l, ir.NewAssignStmt(base.Pos, nr, n.Y))

	nfrm := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nr)
	nto := ir.NewUnaryExpr(base.Pos, ir.OSPTR, nl)

	nlen := typecheck.TempAt(base.Pos, ir.CurFunc, types.Types[types.TINT])

	// n = len(to)
	l = append(l, ir.NewAssignStmt(base.Pos, nlen, ir.NewUnaryExpr(base.Pos, ir.OLEN, nl)))

func testPatchApplication(t *testing.T, original, patch, expected []byte, description string) {
	result, err := jsonpatch.MergePatch(original, patch)
	if err != nil {
		t.Errorf("error: %s\nin test case: %s\ncannot apply patch:\n%s\nto original:\n%s\n",
			err, description, jsonToYAMLOrError(patch), jsonToYAMLOrError(original))
		return
	}

	if !reflect.DeepEqual(result, expected) {

func oneBit16(x int16) bool { return x&(x-1) == 0 && x != 0 }
func oneBit32(x int32) bool { return x&(x-1) == 0 && x != 0 }
func oneBit64(x int64) bool { return x&(x-1) == 0 && x != 0 }

// nto returns the number of trailing ones.
func nto(x int64) int64 {
	return int64(ntz64(^x))
}

// logX returns logarithm of n base 2.
// n must be a positive power of 2 (isPowerOfTwoX returns true).
func log8(n int8) int64 {

    artifactOutput("1. Artifact metadata: hash, name\n2. Direct Super types\n3. Class dependencies")
    originalClasspath(Original classpath)
    originalClasspathInput("Original classpath as input:\nto recalculate Resolve supertypes\nstep on classpath change")
    metadata("1. Artifact metadata: hash, name\n2. Dependencies instrumented type hierarchy")
    result("1. Transformed jar\n2. hash of original jar")

            "version": "v1alpha1"
          }
        ]
      },
      "io.k8s.apimachinery.pkg.runtime.RawExtension": {