withValidityAssertion { analysisSession.expressionInfoProvider.getReturnExpressionTargetSymbol(this) }

    /**
     * Returns cases missing from the branches of [KtWhenExpression].
     *
     * The missing cases of the when-expression in the following example are Direction.WEST and Direction.EAST:
     *
     * enum class Direction {
     *   NORTH, SOUTH, WEST, EAST
     * }

			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

	GV GroupVersion `json:"val"`
}

func TestGroupVersionUnmarshalJSON(t *testing.T) {
	cases := []struct {
		input  []byte
		expect GroupVersion
	}{
		{[]byte(`{"val": "v1"}`), GroupVersion{"", "v1"}},
		{[]byte(`{"val": "apps/v1"}`), GroupVersion{"apps", "v1"}},
	}

	for _, c := range cases {
		var result GroupVersionHolder
		// test golang lib's JSON codec

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.

			json:  `{"name":"foobar"}`,
		},
	}
	for _, tt := range cases {
		t.Run(fmt.Sprintf("%T", tt.input), func(t *testing.T) {
			jb, err := ToJSON(tt.input)
			if err != nil {
				t.Fatal(err)
			}
			if string(jb) != tt.json {
				t.Fatalf("got %v want %v", string(jb), tt.json)
			}
		})
	}
}

func TestToMap(t *testing.T) {
	cases := []struct {
		input Spec
		mp    map[string]any
	}{

		{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},

						Sha256: "fake-sha256",
					},
				},
			},
		},
	}

	for _, tc := range cases {
		t.Run("", func(t *testing.T) {
			u, err := url.Parse(tc.url)
			assert.NoError(t, err)
			got := buildDataSource(u, tc.wasmPlugin)
			assert.Equal(t, tc.expected, got)
		})
	}
}

func TestBuildVMConfig(t *testing.T) {
	cases := []struct {
		desc     string
		vm       *extensions.VmConfig
		policy   extensions.PullPolicy

				} else if len(c.expectedConfName) > 0 {
					t.Fatalf("timed out waiting for expected %s", expectedFilepath)
				} else {
					// Successful test for test cases where CNI config file is never created
					return
				}
			}

			// Only for delayed cases
			select {
			case result := <-resultChan:
				if result != expectedFilepath {
					if len(expectedFilepath) > 0 {

 */

package org.jetbrains.kotlin.analysis.api.impl.base.test.cases.components.scopeProvider

import org.jetbrains.kotlin.analysis.api.KaSession
import org.jetbrains.kotlin.analysis.test.framework.services.expressionMarkerProvider
import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.AbstractSymbolTest
import org.jetbrains.kotlin.analysis.api.impl.base.test.cases.symbols.SymbolsData