steps := []struct {
		added   *v1.ConfigMap
		updated *v1.ConfigMap
		deleted *v1.ConfigMap
	}{
		{added: cm},

		// Handle misconfiguration errors.
		{updated: badCM},
		{updated: cm},
		{updated: badCM2},
		{updated: badCM},
		{updated: cm},
		{updated: badCM3},
		{updated: cm},

		// Handle deletion.
		{deleted: cm},
		{added: cm},
	}

class SortedMapDiffUtilTest extends Specification {

    def "diff #previous and #current"() {
        expect:
        diff(previous, current) == [removed: removed, updated: updated, added: added]

        where:
        previous             | current              | removed              | updated    | added
        ['a', 'b', 'c']      | ['b', 'c', 'd']      | ['a']                | ['b', 'c'] | ['d']

                    newValue.add(j);
                }
                cache.put(key, newValue);
                updated.put(value, newValue);
            }

            checkListEntries(cache, updated);
        }

        cache.reset();

        checkListEntries(cache, updated);

        cache.verify();
        cache.close();
    }

		indata := make([]byte, datalen)
		outgeneric := make([]byte, datalen)
		outdata := make([]byte, datalen)

	fuzzencrypt:
		for {
			select {
			case <-timeout.C:
				break fuzzencrypt
			default:
			}

			rand.Read(indata[:])

			cbcGeneric.CryptBlocks(indata, outgeneric)
			cbcAsm.CryptBlocks(indata, outdata)

			if !bytes.Equal(outdata, outgeneric) {

  if (!updated.hasRank()) return false;

  // If the original type doesn't have a rank, then refine as the updated type
  // has a rank.
  if (!original.hasRank()) return true;

  // Both types must have the same rank.
  if (original.getRank() != updated.getRank()) return false;

  // Refine if the updated type is bounded.
  return IsBounded(updated);
}

      <snapshotVersion>
        <extension>pom</extension>
        <value>0.4.0-20130404.090532-2</value>
        <updated>20130404090532</updated>
      </snapshotVersion>
      <snapshotVersion>
        <extension>jar</extension>
        <value>0.4.0-20130404.093655-3</value>
        <updated>20130404093655</updated>
      </snapshotVersion>
    </snapshotVersions>
  </versioning>

	waitForRun("fifth run", t, timer, obj)

	// Clean up.
	stop <- struct{}{}
	// a message is sent to time.updated in func Stop() at the end of the child goroutine
	// to terminate the child, a receive on time.updated is needed here
	<-timer.updated
}

func Test_BoundedFrequencyRunnerBurst(t *testing.T) {
	obj := &receiver{}
	timer := newFakeTimer()

					return
				}
				if fakeStorage.updated != 0 {
					t.Errorf("unexpected calls to underlying storage.Update: %d", fakeStorage.updated)
					return
				}
			}

			if tc.expectAuthz != (authzCalled > 0) {
				t.Fatalf("expected authz=%v, saw %d calls", tc.expectAuthz, authzCalled)
			}
		})
	}
}

type fakeStorage struct {
	updated int
	created int
	rest.StandardStorage
}

	Link:    []Link{{Href: "http://example.org/"}},
	Updated: ParseTime("2003-12-13T18:30:02Z"),
	Author:  Person{Name: "John Doe"},
	ID:      "urn:uuid:60a76c80-d399-11d9-b93C-0003939e0af6",

	Entry: []Entry{
		{
			Title:   "Atom-Powered Robots Run Amok",
			Link:    []Link{{Href: "http://example.org/2003/12/13/atom03"}},
			ID:      "urn:uuid:1225c695-cfb8-4ebb-aaaa-80da344efa6a",
			Updated: ParseTime("2003-12-13T18:30:02Z"),

					}
					if err := verifyValidatingWebhookConfiguration(got); err != nil {
						return err
					}

					updated := got.DeepCopyObject().(*kubeApiAdmission.ValidatingWebhookConfiguration)
					updated.Webhooks[0].ClientConfig.CABundle = nil
					ignore := kubeApiAdmission.Ignore // can't take the address of a constant
					updated.Webhooks[0].FailurePolicy = &ignore