var c, d Element

	c.Select(&a, &b, 1)
	d.Select(&a, &b, 0)

	if c.Equal(&a) != 1 || d.Equal(&b) != 1 {
		t.Errorf("Select failed")
	}

	c.Swap(&d, 0)

	if c.Equal(&a) != 1 || d.Equal(&b) != 1 {
		t.Errorf("Swap failed")
	}

	c.Swap(&d, 1)

	if c.Equal(&b) != 1 || d.Equal(&a) != 1 {
		t.Errorf("Swap failed")
	}
}

func TestMult32(t *testing.T) {

	}

	tests := []struct {
		a, b  int
		equal bool
	}{
		{0, 1, true},  // same contents, no relocs
		{0, 2, false}, // different contents
		{3, 4, true},  // same contents, same relocs
		{3, 5, true},  // recursively same contents
		{3, 6, false}, // same contents, different relocs
	}
	for _, test := range tests {
		if (h[test.a] == h[test.b]) != test.equal {
			eq := "equal"
			if !test.equal {
				eq = "not equal"
			}

        return Objects.equal(exported, that.exported)
            && Objects.equal(accessRules, that.accessRules)
            && Objects.equal(excludes, that.excludes)
            && Objects.equal(includes, that.includes)
            && Objects.equal(getNativeLibraryLocation(), that.getNativeLibraryLocation())
            && Objects.equal(output, that.output)
            && Objects.equal(path, that.path);
    }

	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	addr, _ = fake.GetAllLocalAddresses()
	if !addr.Equal(expected) {
		t.Errorf("Unexpected mismatch, expected: %v, got: %v", expected, addr)
	}
	fake.SetLocalAddresses("lo", "127.0.0.1")
	expected = nil
	addr, _ = fake.GetLocalAddresses("lo")
	if !addr.Equal(expected) {

   * A specification for which index to return if the list contains at least one element that
   * compares as equal to the key.
   */
  enum KeyPresentBehavior {
    /**
     * Return the index of any list element that compares as equal to the key. No guarantees are
     * made as to which index is returned, if more than one element compares as equal to the key.
     */
    ANY_PRESENT {
      @Override

	// ensure we stored and can fetch both; neither was blown away
	assert.Equal(t,
		s.lookup(s.wleXdsName("emptyaddr1"))[0].GetWorkload().GetName(),
		"emptyaddr1") // can lookup this workload by name
	assert.Equal(t,
		s.lookup(s.wleXdsName("emptyaddr2"))[0].GetWorkload().GetName(),
		"emptyaddr2") // can lookup this workload by name

	assert.Equal(t,
		len(s.lookup(s.addrXdsName(""))),

	if err != nil {
		t.Fatal(err)
	}
	body, err := io.ReadAll(f)
	if err != nil {
		t.Fatal(err)
	}
	assert.Equal(t, body, data)
}

func TestExists(t *testing.T) {
	d := t.TempDir()
	exist := Exists(d)
	assert.Equal(t, exist, true)

	unExist := Exists("unExist")
	assert.Equal(t, unExist, false)

	}

	createPod("128.0.0.1", "pod")
	assert.Equal(t, c.pods.getPodKeys("128.0.0.1"), []types.NamespacedName{{Name: "pod", Namespace: "ns"}})

	// Change the pod IP. This can happen if the pod moves to another node, for example.
	createPod("128.0.0.2", "pod")
	assert.Equal(t, c.pods.getPodKeys("128.0.0.2"), []types.NamespacedName{{Name: "pod", Namespace: "ns"}})
	assert.Equal(t, c.pods.getPodKeys("128.0.0.1"), nil)

	annotations := attr.getAnnotations(auditinternal.LevelMetadata)
	assert.Equal(t, annotations["foo.admission.k8s.io/key1"], "value1")

	// test overwrite
	assert.Error(t, attr.AddAnnotation("foo.admission.k8s.io/key1", "value1-overwrite"),
		"admission annotations should not be allowd to be overwritten")
	annotations = attr.getAnnotations(auditinternal.LevelMetadata)

        }
        ProjectLibrary that = (ProjectLibrary) obj;
        return Objects.equal(name, that.name)
            && Objects.equal(type, that.type)
            && Objects.equal(compilerClasspath, that.compilerClasspath)
            && Objects.equal(classes, that.classes)
            && Objects.equal(javadoc, that.javadoc)
            && Objects.equal(sources, that.sources);
    }

    @Override
    public int hashCode() {