}

    def "forward execution to delegate runnable"() {
        when:
        runner().run()

        then:
        1 * delegate.run()
        0 * _
    }

    def "preserve build operation identifier during execution of the delegate runnable"() {
        given:
        // Set the current build operation to a known value for initializing the runner

        this.gradle = gradle;
        this.features = features;
    }

    @Override
    public void beforeProject(Action<? super Project> action) {
        // Preserve behavior when Isolated Projects is not enabled:
        // - `allprojects` executes eagerly before any project has been evaluated, allowing its effects

        return doCreate(name, type, project, id);
    }

    /**
     * Recreate a task identity.
     * <p>
     * Should only be used when loading from the configuration cache to preserve task ids.
     */
    public <T extends Task> TaskIdentity<T> recreate(String name, Class<T> type, ProjectInternal project, long uniqueId) {
        idFactory.idRecreated();

func (p *pageAlloc) sysInit(test bool) {
	// Reserve memory for each level. This will get mapped in
	// as R/W by setArenas.
	for l, shift := range levelShift {
		entries := 1 << (heapAddrBits - shift)

		// Reserve b bytes of memory anywhere in the address space.
		b := alignUp(uintptr(entries)*pallocSumBytes, physPageSize)
		r := sysReserve(nil, b)
		if r == nil {
			throw("failed to reserve page summary memory")
		}

  std::vector<int32_t> rhs_transpose;
  std::vector<int32_t> out_transpose;
  lhs_transpose.reserve(dnums.lhs_rhs_out.size() + dnums.lhs_out.size() +
                        dnums.lhs_rhs.size());
  rhs_transpose.reserve(dnums.lhs_rhs_out.size() + dnums.rhs_out.size() +
                        dnums.lhs_rhs.size());
  out_transpose.reserve(dnums.lhs_rhs_out.size() + dnums.lhs_out.size() +
                        dnums.rhs_out.size());

    }

    @Override
    public PatternFilterable getPreserve() {
        return delegate.getPreserve();
    }

    @Override
    public SyncSpec preserve(Action<? super PatternFilterable> action) {
        return delegate.preserve(action);
    }

			expectNewSpec: specWithVACName(nil),
			oldSpec:       nil,
			expectOldSpec: nil,
		},
		"enabled vac preserve volume attributes class name": {
			vacEnabled:    true,
			newSpec:       specWithVACName(vacName),
			expectNewSpec: specWithVACName(vacName),
			oldSpec:       nil,
			expectOldSpec: nil,
		},
		"enabled vac preserve volume attributes class name when both old and new have it": {
			vacEnabled:    true,

			cel.DefaultUTCTimeZone(true),

			library.URLs(),
			library.Regex(),
			library.Lists(),

			// cel-go v0.17.7 change the cost of has() from 0 to 1, but also provided the CostEstimatorOptions option to preserve the old behavior, so we enabled it at the same time we bumped our cel version to v0.17.7.
			// Since it is a regression fix, we apply it uniformly to all code use v0.17.7.

//
// * structurality: both `ForbiddenGenerics` and `ForbiddenExtensions` only have zero values, with the two exceptions for IntOrString.
// * RawExtension: for every schema with `x-kubernetes-embedded-resource: true`, `x-kubernetes-preserve-unknown-fields: true` and `type: object` are set
// * IntOrString: for `x-kubernetes-int-or-string: true` either `type` is empty under `anyOf` and `allOf` or the schema structure is one of these:
//
//  1. anyOf:

  llvm::SmallVector<Value, 8> new_packed_inputs;
  llvm::SmallVector<llvm::SmallVector<Value, 8>, 8> replicated_inputs;
  replicated_inputs.reserve(replicate.GetNumReplicatedBlockArguments());
  new_packed_inputs.reserve(replicate.GetNumPackedBlockArguments());
  for (const auto& arg : replicate.GetReplicatedBlockArguments()) {
    replicated_inputs.emplace_back();