case 4:
		return b.NewValue2(pos, OpRsh32Ux64, v.Type, v, s)
	case 2:
		return b.NewValue2(pos, OpRsh16Ux64, v.Type, v, s)
	default:
		base.Fatalf("bad size %d\n", size)
		return nil
	}
}
func byteSwap(b *Block, pos src.XPos, v *Value) *Value {
	switch v.Type.Size() {
	case 8:
		return b.NewValue1(pos, OpBswap64, v.Type, v)
	case 4:
		return b.NewValue1(pos, OpBswap32, v.Type, v)
	case 2:

								cases = append(cases,
									testCase{
										path:  fmt.Sprintf("/policy-%s-all", ns.Prefix()),
										allow: ns.Name() == to.Config().Namespace.Name(),
									})
							}

							// Make sure the workload-specific paths succeeds.
							cases = append(cases,
								testCase{

			wantHas:   true,
		},
	}
	for name, tc := range cases {
		t.Run(name, func(t *testing.T) {
			has := tc.intervals.has(tc.index)
			if has != tc.wantHas {
				t.Errorf("intervalsHaveIndex(_, _) = %t, want %t", has, tc.wantHas)
			}
		})
	}
}

func TestFirstPendingIndexes(t *testing.T) {
	cases := map[string]struct {
		cnt              int
		completions      int

	}

	for _, v := range oidTests {
		oid, ok := newOIDFromDER(v.raw)
		if !ok {
			continue
		}
		cases = append(cases, struct {
			in  string
			out OID
			err error
		}{
			in:  v.str,
			out: oid,
			err: nil,
		})
	}

	for _, tt := range cases {
		o, err := ParseOID(tt.in)
		if err != tt.err {
			t.Errorf("ParseOID(%q) = %v; want = %v", tt.in, err, tt.err)
			continue

using ::stablehlo::quantization::io::CreateTmpDir;
using ::testing::HasSubstr;
using ::tsl::testing::IsOk;
using ::tsl::testing::StatusIs;

// Test cases for `RunQuantization` mainly tests for error cases because testing
// for successful cases require passing python implementation to
// `quantization_py_function_lib`, which requires testing from the python level.

	authorizers = append(authorizers, superuserAuthorizer)

	for _, configuredAuthorizer := range authzConfig.Authorizers {
		// Keep cases in sync with constant list in k8s.io/kubernetes/pkg/kubeapiserver/authorizer/modes/modes.go.
		switch configuredAuthorizer.Type {
		case authzconfig.AuthorizerType(modes.ModeNode):
			if r.nodeAuthorizer == nil {

		{path: "/var/../something", expected: false},
		{path: "/var//lib/something", expected: false},
		{path: "/var/./lib/something", expected: false},
	}

	// Additional cases applicable on Windows
	if runtime.GOOS == "windows" {
		cases = append(cases, []Case{
			{path: "\\", expected: true},
			{path: "C:/var/lib/something", expected: true},
			{path: "C:\\var\\lib\\something", expected: true},
			{path: "C:/", expected: true},

// For example, if childContext is derived from parentContext:
//   - if parentContext is canceled with cause1 before childContext is canceled with cause2,
//     then Cause(parentContext) == Cause(childContext) == cause1
//   - if childContext is canceled with cause2 before parentContext is canceled with cause1,
//     then Cause(parentContext) == cause1 and Cause(childContext) == cause2
type CancelCauseFunc func(cause error)

	for gvk, at := range gvkMap {
		switch gvk {
		case framework.Node, framework.Pod:
			// Do nothing.
		case framework.CSINode:
			if handlerRegistration, err = informerFactory.Storage().V1().CSINodes().Informer().AddEventHandler(
				buildEvtResHandler(at, framework.CSINode, "CSINode"),
			); err != nil {
				return err
			}
			handlers = append(handlers, handlerRegistration)
		case framework.CSIDriver:

			} else {
				// larger simple values encode to two bytes
				each.in = []byte{byte(0xe0) | byte(24), byte(i)}
			}
			switch i {
			case 20, 21, 22, 23: // recognized values with explicit cases
				continue
			case 24, 25, 26, 27, 28, 29, 30, 31: // reserved
				// these are considered not well-formed
				each.assertOnError = assertOnConcreteError(func(t *testing.T, e *cbor.SyntaxError) {