// codegen tests in test/codegen can't really detect ordering
// optimizations like this. Instead, we generate invalid strings with
// bad backing store pointers but nonzero length, so we can check that
// the backing store never gets compared.
//
// We use two different bad strings so that pointer comparisons of
// backing store pointers fail.

package main

import (
	"fmt"
	"reflect"
	"syscall"
	"unsafe"

        """.stripIndent())
    }

    def "custom quiet logging"() {
        when:
        executer.withStackTraceChecksDisabled()
        args("-q")
        fails("test")

        then:
        outputContains("""
            ${maybeParentheses('badTest')} FAILED
                java.lang.RuntimeException: bad

		if err == nil {
			t.Errorf("bad name %q unexpectedly accepted in name constraint", test.name)
			continue
		} else {
			if !test.matcher(err) {
				t.Errorf("bad name %q triggered unrecognised error: %s", test.name, err)
			}
		}
	}
}

func TestBadNamesInSANs(t *testing.T) {
	// Bad names in URI and IP SANs should not parse. Bad DNS and email SANs

	} else {
		got := fmt.Sprintf("%v", err)
		checkWant("meta data", got)
	}

	// Now try to emit counter data file to a bad dir.
	if err := coverage.WriteCountersDir(mangled); err == nil {
		log.Fatal("expected error emitting counter data to bad dir")
	} else {
		got := fmt.Sprintf("%v", err)
		checkWant("counter data", got)
	}
}

func emitToUnwritableDir() {

                BadTask() {
                    println("creating bad task")
                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

            abstract class GoodTask extends DefaultTask {
                @OutputFile

// license that can be found in the LICENSE file.

// Test escape analysis for internal/runtime/atomic.

package escape

import (
	"internal/runtime/atomic"
	"unsafe"
)

// BAD: should always be "leaking param: addr to result ~r0 level=1$".
func Loadp(addr unsafe.Pointer) unsafe.Pointer { // ERROR "leaking param: addr( to result ~r0 level=1)?$"
	return atomic.Loadp(addr)
}

var ptr unsafe.Pointer

import "testing"

func TestA(t *testing.T) {
	if AFunc() != 42 {
		t.Fatalf("bad!")
	}
}
-- b/b.go --
package b

import (
	"M/a"
	"M/d"
)

func BFunc() int {
	return -d.FortyTwo + a.AFunc()
}
-- b/b_test.go --
package b

import "testing"

func TestB(t *testing.T) {
	if BFunc() == 1010101 {
		t.Fatalf("bad!")
	}
}
-- c/c.go --
package c

var G int

        IllegalStateException e = thrown()
        e.message == 'No result has been specified.'
    }

    def "cannot get id when resolve failed"() {
        org.gradle.internal.Factory<String> broken = { "too bad" }
        def failure = new ModuleVersionResolveException(newSelector(DefaultModuleIdentifier.newId("a", "b"), "c"), broken)

        when:
        result.failed(failure)
        result.moduleVersionId

        then:

	// It used to be ok to cast between *unsafe.Pointer and *C.CFTypeRef in a single step.
	// Now we need unsafe.Pointer as an intermediate cast.
	// (*unsafe.Pointer)(x) where x is type *bad -> (*unsafe.Pointer)(unsafe.Pointer(x))
	// (*bad.type)(x) where x is type *unsafe.Pointer -> (*bad.type)(unsafe.Pointer(x))
	walk(f, func(n any) {
		if n == nil {
			return
		}
		// Find pattern like (*a.b)(x)
		c, ok := n.(*ast.CallExpr)
		if !ok {

	}
	switch {
	case hash == crypto.SHA512: // Ed25519ph
		if l := len(message); l != sha512.Size {
			return nil, errors.New("ed25519: bad Ed25519ph message hash length: " + strconv.Itoa(l))
		}
		if l := len(context); l > 255 {
			return nil, errors.New("ed25519: bad Ed25519ph context length: " + strconv.Itoa(l))
		}
		signature := make([]byte, SignatureSize)
		sign(signature, priv, message, domPrefixPh, context)