g := NewWithT(t)
			g.Expect(c.newMap().Len()).To(Equal(c.expected))
		})
	}
}

func TestAddressMapGetAddressesFor(t *testing.T) {
	g := NewWithT(t)

	m := model.AddressMap{
		Addresses: map[cluster.ID][]string{
			c1ID: c1Addresses,
			c2ID: c2Addresses,
		},
	}

	g.Expect(m.GetAddressesFor(c1ID)).To(Equal(c1Addresses))
	g.Expect(m.GetAddressesFor(c2ID)).To(Equal(c2Addresses))
}

	ctl := c.CrdWatcher()
	// Created before informer runs
	assert.Equal(t, ctl.KnownOrCallback(gvr.VirtualService, func(s <-chan struct{}) {
		assert.Equal(t, s, stop)
		vsCalls.Inc()
	}), false)

	c.RunAndWait(stop)
	assert.EventuallyEqual(t, vsCalls.Load, 1)

	// created once running
	assert.Equal(t, ctl.KnownOrCallback(gvr.GatewayClass, func(s <-chan struct{}) {

	g := NewWithT(t)

	// Empty array
	g.Expect(IsExportToAllNamespaces(nil)).To(Equal(true))

	// Array with "*"
	g.Expect(IsExportToAllNamespaces([]string{"*"})).To(Equal(true))

	// Array with "."
	g.Expect(IsExportToAllNamespaces([]string{"."})).To(Equal(false))

	// Array with "." & "*"
	g.Expect(IsExportToAllNamespaces([]string{".", "*"})).To(Equal(true))

	// Array with "bogus"

	t.Setenv(key, strconv.Itoa(expected))
	returnVal, _ := GetEnvAsIntOrFallback(key, 1)
	assert.Equal(expected, returnVal)

	key = "FLOCKER_UNSET_VAR"
	returnVal, _ = GetEnvAsIntOrFallback(key, expected)
	assert.Equal(expected, returnVal)

	key = "FLOCKER_SET_VAR"
	t.Setenv(key, "not-an-int")
	returnVal, err := GetEnvAsIntOrFallback(key, 1)
	assert.Equal(expected, returnVal)
	if err == nil {
		t.Error("expected error")
	}
}

		name string
		x, y *Status
		want bool
	}{
		{
			name: "two nil should be equal",
			x:    nil,
			y:    nil,
			want: true,
		},
		{
			name: "nil should be equal to success status",
			x:    nil,
			y:    NewStatus(Success),
			want: true,
		},
		{
			name: "nil should not be equal with status except success",
			x:    nil,
			y:    NewStatus(Error, "internal error"),

import spock.lang.Specification

class DefaultProblemDefinitionReport extends Specification {
    def "equal objects are equal"() {
        when:
        def pd1 = createProblemDefinition()
        def pd2 = createProblemDefinition()

        then:
        pd1 == pd2
        pd1 == pd1
    }

    def "Changed label causes equal to be false"() {

        when:
        def pd1 = createProblemDefinition()

		value, _ := smt.get(root, key, nil, 0, smt.trieHeight)
		if !bytes.Equal(values[i], value) {
			t.Fatal("value not updated")
		}
	}

	// Append to the trie
	newKeys := getFreshData(5)
	newValues := getFreshData(5)
	ch = make(chan result, 1)
	smt.update(root, newKeys, newValues, nil, 0, smt.trieHeight, false, true, ch)
	res = <-ch
	newRoot := res.update
	if bytes.Equal(root, newRoot) {
		t.Fatal("trie not updated")
	}

	}
	pc.CreateOrUpdateStatus(pod)
	tt.WaitUnordered("add/namespace/name")
	assert.Equal(t, fetchSorted("1.2.3.4"), []SimplePod{{NewNamed(pod), Labeled{}, "1.2.3.4"}})

	pod.Status.PodIP = "1.2.3.5"
	pc.UpdateStatus(pod)
	tt.WaitUnordered("update/namespace/name")
	assert.Equal(t, fetchSorted("1.2.3.4"), []SimplePod{})
	assert.Equal(t, fetchSorted("1.2.3.5"), []SimplePod{{NewNamed(pod), Labeled{}, "1.2.3.5"}})

	pod2 := &corev1.Pod{

	t.Run("extract typed", func(t *testing.T) {
		assert.Equal(t, Extract[*corev1.Pod](obj), obj)
		assert.Equal(t, Extract[*corev1.Pod](random), nil)
		assert.Equal(t, Extract[*corev1.Pod](tombstone), obj)
	})

	t.Run("extract object", func(t *testing.T) {
		assert.Equal(t, Extract[Object](obj), Object(obj))
		assert.Equal(t, Extract[Object](obj), Object(obj))
		assert.Equal(t, Extract[Object](random), nil)
	})

				return res, nil
			}

			return res, fmt.Errorf("not yet")
		})
		res, err := l.Get()
		assert.Error(t, err)
		assert.Equal(t, res, 1)

		res, err = l.Get()
		assert.Error(t, err)
		assert.Equal(t, res, 2)

		res, err = l.Get()
		assert.NoError(t, err)
		assert.Equal(t, res, 3)
	})

	t.Run("no retry", func(t *testing.T) {
		computations := atomic.NewInt32(0)
		l := New(func() (int32, error) {