return err
	}
	_, err = c.UpdateStatus(context.TODO(), updatedSV, metav1.UpdateOptions{})
	return err
}

// localUpdateStorageVersion updates the input storageversion with given server storageversion info.
// The function updates the input storageversion in place.

cp incomplete-sum-file $WORK/overlay/overlay-sum-used-correct-sums
! go get -overlay overlay.json .
stderr '^go: updates to go.sum needed, but go.sum is part of the overlay specified with -overlay$'
cmp incomplete-sum-file $WORK/overlay/overlay-sum-used-correct-sums
! go mod tidy -overlay overlay.json
stderr '^go: updates to go.sum needed, but go.sum is part of the overlay specified with -overlay$'

	// will be mirrored to an EndpointSlice for an EndpointSubset.
	MirroringMaxEndpointsPerSubset int32

	// mirroringEndpointUpdatesBatchPeriod can be used to batch EndpointSlice
	// updates. All updates triggered by EndpointSlice changes will be delayed
	// by up to 'mirroringEndpointUpdatesBatchPeriod'. If other addresses in the
	// same Endpoints resource change in that period, they will be batched to a

	if err != nil {
		return nil, false, err
	}
	endpoints := obj.(*api.Endpoints)
	// TODO: support namespaces in this mock
	e.lock.Lock()
	defer e.lock.Unlock()

	e.Updates = append(e.Updates, *endpoints)

	if e.Err != nil {
		return nil, false, e.Err
	}
	if e.Endpoints == nil {
		e.Endpoints = &api.EndpointsList{
			Items: []api.Endpoints{
				*endpoints,
			},
		}

apiVersion: release-notes/v2
kind: feature
area: installation
issue:
- 31946
releaseNotes:
- |

---
version: 2
updates:
  - package-ecosystem: gomod
    directory: /
    schedule:
      interval: weekly
  - package-ecosystem: github-actions
    directory: /
    schedule:
      interval: weekly
  - package-ecosystem: gomod
    directory: /tests
    schedule:

				expect(0, 0)
			},
		},
		{
			name: "Should send full updates in batches",
			test: func(updateCh chan *model.PushRequest, expect func(partial, full int32)) {
				updateCh <- &model.PushRequest{Full: true}
				updateCh <- &model.PushRequest{Full: true}
				expect(0, 1)
			},
		},
		{
			name: "Should send full updates in batches, partial updates immediately",

 */
package org.gradle.cache.internal;

import org.gradle.cache.UnitOfWorkParticipant;

import javax.annotation.Nullable;
import java.util.function.Function;

/**
 * An indexed cache that may perform updates asynchronously.
 */
public interface MultiProcessSafeAsyncPersistentIndexedCache<K, V> extends UnitOfWorkParticipant {
    /**
     * Fetches the given entry, blocking until the result is available.
     */
    @Nullable

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

#include "textflag.h"

// castagnoliUpdate updates the non-inverted crc with the given data.

// func castagnoliUpdate(crc uint32, p []byte) uint32
TEXT ·castagnoliUpdate(SB),NOSPLIT,$0-36
	MOVWU	crc+0(FP), R9  // CRC value
	MOVD	p+8(FP), R13  // data pointer
	MOVD	p_len+16(FP), R11  // len(p)

		select {
		case u := <-m.Updates():
			if expected != u {
				t.Errorf("Expected update %v, received %v: %s", expected, u, msg)
			}
		case <-time.After(wait.ForeverTestTimeout):
			t.Errorf("Timed out waiting for update %v: %s", expected, msg)
		}
	}

	expectNoUpdate := func(msg string) {
		// NOTE: Since updates are accumulated asynchronously, this method is not guaranteed to fail