}

        protected
        fun illegalState(): Nothing = throw IllegalStateException("This operation is not supported while in the ${javaClass.simpleName} state.")

        class Initial() : State() {

            private
            val actions = mutableListOf<RegisteredFlowAction>()

            override val pendingActions: List<RegisteredFlowAction>
                get() = actions

	// by the method specified in 3.3 of [1].
	// It is stored here in order for Reset() to be able to put context into
	// initial state.
	initBlock []byte
}

// Consts for configuring initial SHA-3 state
const (
	dsbyteShake  = 0x1f
	dsbyteCShake = 0x04
	rate128      = 168
	rate256      = 136
)

func bytepad(input []byte, w int) []byte {

 * limitations under the License.
 */

package org.gradle.internal

import spock.lang.Specification

class MutableReferenceTest extends Specification {

    def "initial value is kept"() {
        def object = "object"
        expect:
        MutableReference.empty().get() == null
        MutableReference.of(null).get() == null
        MutableReference.of(object).get() is object
    }

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

package org.gradle.tooling.internal.protocol;

/**
 * Initial configuration for a provider connection.
 *

	}
	return uint64(currentResourceVersion), nil
}

// AnnotateInitialEventsEndBookmark adds a special annotation to the given object
// which indicates that the initial events have been sent.
//
// Note that this function assumes that the obj's annotation
// field is a reference type (i.e. a map).
func AnnotateInitialEventsEndBookmark(obj runtime.Object) error {

using ::tensorflow::protobuf::Map;
using ::tensorflow::protobuf::Message;
using ::tensorflow::protobuf::RepeatedPtrField;

// Number of sequential FieldIndex matches of `a` in `b`. (Length of initial
// subsequence.)
// Example: `a = {4, 2}`, `b = {4, 2, 1, 3}`, `fieldTagMatches(a, b) == 2`
absl::StatusOr<int> fieldTagMatches(
    const RepeatedPtrField<::tensorflow::proto_splitter::FieldIndex>& a,

class ForkOptionsTest extends Specification {
    static final List PROPS = ['executable', 'memoryInitialSize', 'memoryMaximumSize', 'tempDir']

    ForkOptions forkOptions = TestUtil.newInstance(ForkOptions)

    def 'initial values of forkOptions'() {
        expect:
        forkOptions.executable == null
        forkOptions.javaHome == null
        forkOptions.memoryInitialSize == null
        forkOptions.memoryMaximumSize == null

func (d dummyValue) ResourceName() string {
	return ""
}

type StaticSingleton[T any] interface {
	Singleton[T]
	Set(*T)
}

func NewStatic[T any](initial *T) StaticSingleton[T] {
	val := new(atomic.Pointer[T])
	val.Store(initial)
	x := &static[T]{
		val:           val,
		id:            nextUID(),
		eventHandlers: &handlers[T]{},
	}
	return collectionAdapter[T]{x}
}

		name       string
		invariants func(set *apps.StatefulSet, om *fakeObjectManager) error
		initial    func() *apps.StatefulSet
		update     func(set *apps.StatefulSet) *apps.StatefulSet
		validate   func(set *apps.StatefulSet, pods []*v1.Pod) error
	}

	testFn := func(test *testcase, t *testing.T) {
		set := test.initial()
		client := fake.NewSimpleClientset(set)
		om, _, ssc := setupController(client)

 * limitations under the License.
 */

package org.gradle.launcher.daemon.client;

/**
 * Thrown when connected to a stale daemon address.
 *
 * This is thrown instead of using an initial handshake on the connection, to avoid the latency of a round trip to the
 * daemon before starting the build.
 */
public class StaleDaemonAddressException extends DaemonConnectionException {