description         string
		deviceIDs           []string
		expecteError        error
		expectedAnnotations []container.Annotation
	}{
		{
			description: "no devices",
			deviceIDs:   []string{},
		},
		{
			description:         "one device",
			deviceIDs:           []string{"vendor.com/class=device1"},

		pod                 *api.Pod
		verifierAnnotations map[string]string
		expectedAnnotations map[string]string
		wantErr             bool
	}{
		{
			test: "Add valid response annotations",
			pod:  goodPod("good"),
			verifierAnnotations: map[string]string{
				"foo-test": "true",
				"bar-test": "false",
			},
			expectedAnnotations: map[string]string{

		assert.Equal(t, "", image.Spec.RuntimeHandler, "image.Spec.RuntimeHandler not empty", "ImageID", image.ID)

		expectedAnnotations := []Annotation{
			{
				Name:  "kubernetes.io/runtimehandler",
				Value: "handler_name",
			}}
		assert.Equal(t, expectedAnnotations, image.Spec.Annotations, "image spec annotations")
	})
}

				"Diff: %s", cmp.Diff(testCase.expectedAddresses, existingNode.Status.Addresses))
			if testCase.expectedAnnotations != nil {
				assert.True(t, apiequality.Semantic.DeepEqual(testCase.expectedAnnotations, existingNode.Annotations),
					"Diff: %s", cmp.Diff(testCase.expectedAnnotations, existingNode.Annotations))
			}
		})
	}
}

                def expectedAnnotation = expectedAnnotations[category]
                if (expectedAnnotation instanceof Class) {
                    assert actualAnnotation.annotationType() == expectedAnnotation
                } else if (expectedAnnotation instanceof Closure) {
                    assert expectedAnnotation.call(actualAnnotation)
                } else {

	for _, test := range []struct {
		description         string
		claimInfo           *ClaimInfo
		devices             []string
		expectedCDIDevices  map[string][]string
		expectedAnnotations map[string][]kubecontainer.Annotation
		wantErr             bool
	}{
		{
			description: "successfully add one device",
			claimInfo: &ClaimInfo{
				ClaimInfoState: state.ClaimInfoState{

			t.Fatalf("for: %s; expected expansionCalled to be %v but was %v", test.name, test.expansionCalled, expansionCalled)
		}

		if len(test.expectedAnnotation) != 0 && !reflect.DeepEqual(test.expectedAnnotation, pvc.Annotations) {
			t.Fatalf("for: %s; expected %v annotations, got %v", test.name, test.expectedAnnotation, pvc.Annotations)
		}
	}
}

		numDesiredNotReady  int
		numExpectedReady    int
		numExpectedNotReady int
		expectedAnnotation  bool
	}{{
		name:                "empty",
		startingAnnotation:  nil,
		numExisting:         0,
		numDesired:          0,
		numExpectedReady:    0,
		numExpectedNotReady: 0,
		expectedAnnotation:  false,
	}, {