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

package org.gradle.workers;

/**
 * A worker spec providing the requirements of a forked process with a custom classpath.
 *
 * @since 5.6
 */
public interface ProcessWorkerSpec extends ForkingWorkerSpec, ClassLoaderWorkerSpec {

Laura Kassovic <******@****.***> 1701107622 -0800

                    parameters.outputFile.set(outputFile)
                }

                // forces the service to be initialized immediately when configuration cache loads its cache
                gradle.services.get(BuildEventListenerRegistryInternal).onOperationCompletion(outputProgress)

                // forces the service to be initialized immediately
                outputProgress.get()
            }
       """

Laura Kassovic <******@****.***> 1701107622 -0800

    WHEEL_MEGABYTES=$(stat --format %s "$TF_WHEEL" | awk '{print int($1/(1024*1024))}')
    # Googlers: search for "test_tf_whl_size"
    case "$TF_WHEEL" in
        # CPU:
        *cpu*manylinux*) LARGEST_OK_SIZE=220 ;;
        # GPU:
        *manylinux*)     LARGEST_OK_SIZE=580 ;;
        # Unknown:
        *)
            echo "The wheel's name is in an unknown format."
            exit 1
            ;;
    esac

	for i := 0; i < runs; i++ {
		f()
	}

	// Read the final statistics
	runtime.ReadMemStats(&memstats)
	mallocs += memstats.Mallocs

	// Average the mallocs over the runs (not counting the warm-up).
	// We are forced to return a float64 because the API is silly, but do
	// the division as integers so we can ask if AllocsPerRun()==1
	// instead of AllocsPerRun()<2.
	return float64(mallocs / uint64(runs))

            sync.releaseAll()
            resultHandler.finished()
        }

        then:
        noExceptionThrown()
    }

    def "can cancel build through forced stop"() {
        // in-process call does not support forced stop
        toolingApi.requireDaemons()
        buildFile << """
task hang {
    doLast {
        ${server.callFromBuild("waiting")}
    }
}
"""

				// If not found, the policy is being deleting, do nothing.
				return nil
			}
			return err
		}
		return c.reconcile(ctx, policy)
	}()

	if err == nil {
		c.policyQueue.Forget(key)
		return true
	}

	utilruntime.HandleError(err)
	c.policyQueue.AddRateLimited(key)

	return true
}

	testCases := map[string]struct {
		jwt           string
		jwtPath       string
		expectedToken string
		expectedCall  int
	}{
		// mock metadata server returns an expired token, that forces rotation job
		// to fetch new token during each rotation.
		"expired token needs rotation": {
			jwt:           thirdPartyJwt,

	"internal/stringslite"
	"sync/atomic"
)

var required atomic.Bool

// Force forces crypto/tls to restrict TLS configurations to FIPS-approved settings.
// By design, this call is impossible to undo (except in tests).
//
// Note that this call has an effect even in programs using
// standard crypto (that is, even when Enabled = false).
func Force() {
	required.Store(true)
}

// Abandon allows non-FIPS-approved settings.