return TaggedValue(args.tuple()[0].i64() + args.tuple()[1].i64());
}

int64_t AddRaw(int64_t a, int64_t b) { return a + b; }

}  // namespace

// Add numbers in a loop by calling a callable.
void CallFunctions(::testing::benchmark::State& state) {
  Integer sum(0);
  Callable callable((impl::TaggedValue(impl::Func(AddTagged))));
  *callable.Call<Integer>(sum, Integer(30));
  size_t i = 0;

			if err == nil && tc.expectedError != nil {
				t.Errorf("calling NewEgressSelector expected error: %s, did not get it", *tc.expectedError)
			}
			if err != nil && tc.expectedError == nil {
				t.Errorf("unexpected error calling NewEgressSelector got: %#v", err)
			}
			if err != nil && tc.expectedError != nil && err.Error() != *tc.expectedError {
				t.Errorf("calling NewEgressSelector expected error: %s, got %#v", *tc.expectedError, err)

    }

    def "calling deprecated usage produces a deprecation warning"() {
        given:
        buildFile << """
            configurations.consumable('custom')

            configurations.custom.getConsistentResolutionSource()
        """

        expect:

     */
    List<ComponentVariantIdentifier> getCandidates();

    /**
     * Selects a particular candidate to solve the conflict. It is recommended to
     * provide a human-readable explanation to the choice by calling the {@link #because(String)} method
     *
     * @param candidate the selected candidate
     * @return this details instance
     *
     * @since 6.0
     */

    }

    def "does not fail when calling get() after producer task has completed"() {
        given:
        def property = propertyWithCompletedProducer()
        def provider = property.filter { it.contains("1") }

        when:
        provider.get()

        then:
        noExceptionThrown()
    }

    def "fails when calling getOrNull() before producer task has completed"() {
        given:

	if !volumetest.MetricsEqualIgnoreTimestamp(actual, expected) {
		t.Errorf("Expected empty Metrics from uninitialized MetricsBlock, actual %v", *actual)
	}
	if err == nil {
		t.Errorf("Expected error when calling GetMetrics on uninitialized MetricsBlock, actual nil")
	}

	metrics = NewMetricsBlock("/nonexistent/device/node")
	actual, err = metrics.GetMetrics()
	if !volumetest.MetricsEqualIgnoreTimestamp(actual, expected) {

 * are possible and creating a lazy provider can be done by calling
 * one of the factory methods:
 * <ul>
 *     <li>{@link #unsafe()} would create a lazy wrapper which performs no synchronization at all when calling the supplier: it may be called several times concurrently by different threads. Not thread safe!</li>

interface ProblemFactory {
    /**
     * Returns a default location inferred from the calling thread's state.
     */
    fun locationForCaller(consumer: String? = null): PropertyTrace

    /**
     * Creates a problem with the given message and exception.
     *
     * Problem has no documentation, and a default location is inferred from the calling thread's state.
     */

.file "gcc_s390x.S"

/*
 * void crosscall_s390x(void (*fn)(void), void *g)
 *
 * Calling into the go tool chain, where all registers are caller save.
 * Called from standard s390x C ABI, where r6-r13, r15, and f8-f15 are
 * callee-save, so they must be saved explicitly.
 */
.globl crosscall_s390x
crosscall_s390x:
	/* save r6-r15 in the register save area of the calling function */
	stmg    %r6, %r15, 48(%r15)

     *
     * @return the value from the producer
     */
    @Nullable
    T getProducerValue();

    /**
     * Calling this method will indicate that the attributes are compatible.
     */
    void compatible();

    /**
     * Calling this method will indicate that the attributes are incompatible.
     */
    void incompatible();