if resp != nil && resp.User != nil {
		tokenReview.Status.User = authentication.UserInfo{
			Username: resp.User.GetName(),
			UID:      resp.User.GetUID(),
			Groups:   resp.User.GetGroups(),
			Extra:    map[string]authentication.ExtraValue{},
		}
		for k, v := range resp.User.GetExtra() {
			tokenReview.Status.User.Extra[k] = authentication.ExtraValue(v)
		}
		tokenReview.Status.Audiences = resp.Audiences
	}

	{"1.38.1", rel2, "go1.39.2"},
	{"1.38.1", relRC, "go1.39.2"},
	{"1.39", rel0, "go1.39.2"},
	{"1.39", rel2, "go1.39.2"},
	{"1.39", relRC, "go1.39.2"},
	{"1.39.2", rel0, "go1.39.2"},
	{"1.39.2", rel2, "go1.39.2"},
	{"1.39.2", relRC, "go1.39.2"},
	{"1.39.3", rel0, "go1.40.0"},
	{"1.39.3", rel2, "go1.40.2"},
	{"1.39.3", relRC, "go1.40.2"},
	{"1.40", rel0, "go1.40.0"},
	{"1.40", rel2, "go1.40.2"},

    }


@app.get(
    "/mixed",
    response_model=Model3,
    response_model_include={"ref2", "name"},
    response_model_exclude={"ref2": {"baz"}},
)
def mixed():
    return Model3(
        name="mixed model3 name",
        age=3,
        ref2=Model2(
            ref=Model1(foo="mixed model foo", bar="mixed model bar"),
            baz="mixed model2 baz",
        ),
    )

	VSQ   RED1, RED2, RED2      // Guaranteed not to underflow

	VSLDB $8, T1, T0, T0
	VSLDB $8, T2, T1, T1

	VACCQ  T0, RED1, CAR1
	VAQ    T0, RED1, T0
	VACCCQ T1, RED2, CAR1, CAR2
	VACQ   T1, RED2, CAR1, T1
	VAQ    T2, CAR2, T2

	// Second round
	VPERM T1, T0, SEL1, RED2    // d1 d0 d1 d0
	VPERM ZER, RED2, SEL2, RED1 // 0  d1 d0  0
	VSQ   RED1, RED2, RED2      // Guaranteed not to underflow

	VSLDB $8, T1, T0, T0

    missing="false"
    beingDeleted="false"
    deletingDependents="false"
    virtual="false"
  ];
  "ref2-" [
    label="uid=ref2-\nnamespace=ref2ns\nref2kind-.version.ref2group/ref2name-\n"
    group="ref2group"
    version="version"
    kind="ref2kind-"
    namespace="ref2ns"
    name="ref2name-"
    uid="ref2-"
    missing="false"
    beingDeleted="false"
    deletingDependents="false"
    virtual="false"
  ];

        assertEquals(dfsTestSharePath.length() - 1, ref.getPathConsumed());

        DfsReferralData ref2 = doResolve(dfsTestSharePath, "", true, true);

        assertNotNull(ref2);
        assertEquals(getTestDfsTargetServer().toLowerCase(Locale.ROOT), ref2.getServer().toLowerCase(Locale.ROOT));
        assertEquals(dfsTestSharePath.length() - 1, ref2.getPathConsumed());
    }


    @Test

		resp, err := http.DefaultClient.Do(req)
		if err != nil {
			t.Errorf("%d: unexpected error: %v", i, err)
			continue
		}
		defer resp.Body.Close()
		if resp.StatusCode != http.StatusOK {
			t.Errorf("%d: unexpected status: %d from url %s, Expected: %d, %#v", i, resp.StatusCode, testCase.url, http.StatusOK, resp)
			body, err := ioutil.ReadAll(resp.Body)
			if err != nil {

// CHECK:       [[RES_2:%.*]] = "tf.Mul"([[RES_1]], [[CST_1]])
// CHECK:       tf.WhileRegion
// CHECK:       ^bb0
// CHECK:       tf.OpA
// CHECK:       ^bb0([[ARG_2:%[a-zA-Z0-9_]+]]
// CHECK-SAME:  [[ARG_3:%[a-zA-Z0-9_]+]]: tensor<i32>)
// CHECK-NEXT:  [[RES_3:%.*]] = "tf.AddV2"([[ARG_2]], [[RES_1]])
// CHECK-NEXT:  [[RES_4:%.*]] = "tf.Div"([[ARG_3]], [[RES_2]])
// CHECK:       "tf.Yield"([[RES_3]], [[RES_4]])

type SG1 struct {
	SG
}

type sFG struct {
	F int
	G int
}

type RS1 struct {
	i int
}

type RS2 struct {
	RS1
}

type RS3 struct {
	RS2
	RS1
}

type M map[string]any

type Rec1 struct {
	*Rec2
}

type Rec2 struct {
	F string
	*Rec1
}

func TestFields(t *testing.T) {
	for _, test := range fieldsTests {
		test := test

                    SmbComNTCreateAndX req2 = new SmbComNTCreateAndX(sess.getConfig(), uncPath, flags, access, sharing, attrs, options, null);
                    req2.addFlags0(0x2); // REQUEST_OPLOCK
                    req2.setOverrideTimeout(1000);
                    req2.setResponse(resp2);

                    try {
                        resp2 = tree.send(req2);
                    }