nodeInfo: nodeInfo{
			memoryPhysicalCapacityBytes: 100,
		},
	}

	machineInfo, err := p.getMachineInfo()
	assert.NoError(t, err)
	assert.Equal(t, uint64(100), machineInfo.MemoryCapacity)
	hostname, _ := os.Hostname()
	assert.Equal(t, hostname, machineInfo.MachineID)

	// Check if it's an UUID.
	_, err = uuid.Parse(machineInfo.SystemUUID)
	assert.NoError(t, err)

			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))
}

}

func TestEqual(t *testing.T) {
	for i, test := range equalTests {
		A, err := Parse(test.A)
		if err != nil {
			t.Fatalf("Test %d: %v", i, err)
		}
		B, err := Parse(test.B)
		if err != nil {
			t.Fatalf("Test %d: %v", i, err)
		}
		if equal := Equal(A, B); equal != test.Equal {
			t.Fatalf("Test %d: got %v - want %v", i, equal, test.Equal)
		}
	}
}

	for _, test := range equalIntTests {
		if got := Equal(test.s1, test.s2); got != test.want {
			t.Errorf("Equal(%v, %v) = %t, want %t", test.s1, test.s2, got, test.want)
		}
	}
	for _, test := range equalFloatTests {
		if got := Equal(test.s1, test.s2); got != test.wantEqual {
			t.Errorf("Equal(%v, %v) = %t, want %t", test.s1, test.s2, got, test.wantEqual)
		}
	}
}

// equal is simply ==.
func equal[T comparable](v1, v2 T) bool {

	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"

	imageRef, err := fakeManager.PullImage(ctx, kubecontainer.ImageSpec{Image: "busybox"}, nil, nil)
	assert.NoError(t, err)
	assert.Equal(t, "busybox", imageRef)

	images, err := fakeManager.ListImages(ctx)
	assert.NoError(t, err)
	assert.Equal(t, 1, len(images))
	assert.Equal(t, images[0].RepoTags, []string{"busybox"})
}

func TestPullImageWithError(t *testing.T) {
	ctx := context.Background()

	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()