})
	if err != nil {
		t.Fatal(err)
	}

	testCases := map[string]struct {
		exts           []pkix.Extension
		expectedIDs    []string
		expectedErrMsg string
	}{
		"Empty extension list": {
			exts:           []pkix.Extension{},
			expectedIDs:    nil,
			expectedErrMsg: "the SAN extension does not exist",
		},
		"Extensions without SAN": {
			exts: []pkix.Extension{

            expectedIds << cs.id.module
            conflict = handler.registerCandidate(
                candidate(capability, cs)
            )
        }

        then:
        def actualIds = []
        conflict.withParticipatingModules {
            actualIds << it
        }

        actualIds == expectedIds
    }

			}
			if err != nil {
				return
			}
			if len(tc.expectedIDs) != len(got) {
				t.Fatalf("expected id %d, got %d", len(tc.expectedIDs), len(got))
			}
			for i := range got {
				if !reflect.DeepEqual(tc.expectedIDs[i], got[i]) {
					t.Fatalf("expected id at position %d: %+v, got: %+v", i, tc.expectedIDs[i], got[i])
				}
			}
		})
	}
}

func TestAddEntries(t *testing.T) {

    ASSERT_EQ(errors::OK, s.code()) << s.message();
    B.reset(B_raw);
  }

  float expected_dA[4] = {-.5f, 2.0f, -.5f, 2.0f};
  ASSERT_NO_FATAL_FAILURE(CompareNumericalAndManualGradients(
      MatMulModel, ctx_.get(), {A.get(), B.get()}, 0, expected_dA, 4,
      UseFunction()));
}

TEST_P(GradientCheckerTest, TestMul) {
  AbstractTensorHandlePtr x;
  {

			for caseIndex, expectedPos := range expectedPositions {
				actualPosition := v.fset.PositionFor(ident.Pos(), true)
				errorOccured := false
				if expectedPos.Line != actualPosition.Line {
					fmt.Fprintf(&errorMessage, "wrong line number for ident %s: expected: %d got: %d\n", ident.Name, expectedPos.Line, actualPosition.Line)
					errorOccured = true
				}
				if expectedPos.Column != actualPosition.Column {

        for (int expectedIdx = 0; expectedIdx < expectedLines.size(); expectedIdx++) {
            int actualIdx = actualMatchStartIdx + expectedIdx;
            if (actualIdx >= actualLines.size() || !Objects.equals(expectedLines.get(expectedIdx), actualLines.get(actualIdx))) {
                return false;
            }
        }
        return true;

			if !apiequality.Semantic.DeepEqual(tc.newEPS, tc.expectedEPS) {
				t.Errorf("Expected %+v\nGot: %+v", tc.expectedEPS, tc.newEPS)
			}
		})
	}
}

func Test_dropTopologyOnV1(t *testing.T) {
	testcases := []struct {
		name        string
		v1Request   bool
		newEPS      *discovery.EndpointSlice
		originalEPS *discovery.EndpointSlice
		expectedEPS *discovery.EndpointSlice
	}{
		{

        List<Boolean> result = new ArrayList<>(expectedLines.size());
        for (int expectedIdx = 0; expectedIdx < expectedLines.size(); expectedIdx++) {
            int actualIdx = matchBeginsActualIdx + expectedIdx;
            String expected = expectedLines.get(expectedIdx);
            String actual = actualLines.get(actualIdx);
            result.add(Objects.equals(expected, actual));
        }

			name:          "z",
			expectedValue: "",
			expectedIdx:   -1,
			startIdx:      -1,
		},
	}

	for _, rt := range tests {
		t.Run(rt.testName, func(t *testing.T) {
			value, idx := GetArgValue(rt.args, rt.name, rt.startIdx)
			if idx != rt.expectedIdx {
				t.Errorf("expected index: %v, got: %v", rt.expectedIdx, idx)
			}
			if value != rt.expectedValue {

		expectedErr      string
		expectedToken    string
		expectedIdp      string
	}{
		"gce test": {
			fetcherType:      security.GCE,
			trustdomain:      "abc.svc.id.goog",
			jwtPath:          "/var/run/secrets/tokens/istio-token",
			identityProvider: security.GCE,
			expectedErr:      "", // No error when ID token auth is enabled.
			expectedToken:    "",
			expectedIdp:      "GoogleComputeEngine",
		},
		"mock test": {