// A call stub is usually needed when the ELFv2 st_other attribute is different
// between caller and callee.
//
// The type of call stub inserted will vary depending on GOPPC64 and the
// buildmode (e.g pie builds shared code, default builds fixed-position code).
// CI is set up to run for P8 and P10 machines, and this test is run in both
// pie and default modes.
//

        keyStore.configureServerAndClientCerts(executer)
        fails "libs"

        then:
        failure.assertHasCause("Could not GET '${server.uri}/repo1/my-group/my-module/1.0/")
        // exact error might vary depending on JVM version and OS
        failure.assertThatCause(matchesRegexp("Got (socket|SSL handshake) exception during request. It might be caused by SSL misconfiguration"))
    }

// Reads may be cached or uncached, depending on the input client.
func WrapReadWriter[T controllers.Object](t test.Failer, c kclient.ReadWriter[T]) TestClient[T] {
	return TestClient[T]{
		c: c,
		t: t,
		TestWriter: TestWriter[T]{
			c: c,
			t: t,
		},
	}
}

// Wrap returns a client that calls t.Fatal on errors.
// Reads may be cached or uncached, depending on the input client.

        when:
        fails ':compileJava'

        then:
        failure.assertHasErrorOutput '(package moda.internal is declared in module moda, which does not export it)'
    }

    def "compiles a module depending on an automatic module"() {
        given:
        publishAutoModule('moda')
        consumingModuleInfo('requires moda')
        consumingModuleClass('moda.ModaClass', 'moda.internal.ModaClassInternal')

        when:

    private final boolean useUnifiedDiff;

    private ExhaustiveLinesSearcher(boolean useUnifiedDiff) {
        this.useUnifiedDiff = useUnifiedDiff;
    }

    /**
     * Uses the git diff algorithm for presenting matches.
     * <p>
     * Enabling this option will only show a single match, regardless of how many potential matches
     * containing the same number of matching lines are found.
     *

    /**
     * Marks the supplied file as accessed.
     *
     * If the supplied file is unknown to this tracker, implementations must
     * simply ignore it instead of throwing an exception. However, depending
     * on the use case, implementations may throw an exception when marking a
     * known file fails.
     */
    void markAccessed(File file);

 */

package org.gradle.buildinit.plugins.internal

import spock.lang.Specification


class ConditionalTemplateOperationSpec extends Specification {

    def "triggers delegates depending on condition"(){
        TemplateOperation operation1 = Mock(TemplateOperation)
        TemplateOperation operation2 = Mock(TemplateOperation)

        Mock(org.gradle.internal.Factory).create() >> true
        when:

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.nativeplatform.fixtures.app

/**
 * A Swift app depending on a library that remove all sources.
 */
class IncrementalSwiftStaleLinkOutputAppWithLib {
    final lib = new IncrementalSwiftLib()
    final main = new IncrementalSwiftAppWithDep(lib)

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Minimal copy of x/sys/unix so the cpu package can make a
// system call on AIX without depending on x/sys/unix.
// (See golang.org/issue/32102)

//go:build aix && ppc64 && gc

package cpu

import (
	"syscall"
	"unsafe"
)

//go:cgo_import_dynamic libc_getsystemcfg getsystemcfg "libc.a/shr_64.o"

	}
	return max, maxErr
}

// reduceQuorumErrs behaves like reduceErrs by only for returning
// values of maximally occurring errors validated against a generic
// quorum number that can be read or write quorum depending on usage.
func reduceQuorumErrs(ctx context.Context, errs []error, ignoredErrs []error, quorum int, quorumErr error) error {
	if contextCanceled(ctx) {
		return context.Canceled
	}