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

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

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

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

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

	}
	if want.Name != "" {
		assert.Equal(t, want.Name, have.Name, context("name should be equal"))
	}
	if want.Type != "" {
		assert.Equal(t, want.Type, haveType, context(fmt.Sprintf("type should be equal (%+v)", have.FilterChainMatch)))
	}
	if want.Port != 0 {
		assert.Equal(t, want.Port, have.GetFilterChainMatch().GetDestinationPort().GetValue(), context("port should be equal"))
	}

		},
		Stats: stats,
	}

	assert.Equal(t, len(actualRootInfos), len(infos))
	assert.Equal(t, actualRootInfos["/"].Spec, infos["/"].Spec)
	assert.Equal(t, len(actualRootInfos["/"].Stats), len(infos["/"].Stats))
	assert.Equal(t, actualRootInfos["/"].Stats[0].Cpu, infos["/"].Stats[0].Cpu)
	assert.Equal(t, actualRootInfos["/"].Stats[0].CpuInst, infos["/"].Stats[0].CpuInst)

	m.DocRef = "test-ref"

	mb := m.UnstructuredAnalysisMessageBase()
	g.Expect(mb["documentationUrl"]).To(Equal(fmt.Sprintf("%s/%s/%s", url.ConfigAnalysis, "ist0042", "?ref=test-ref")))
	g.Expect(mb["level"]).To(Equal("ERROR"))
	g.Expect(mb["type"]).To(Equal(
		map[string]any{
			"code": "IST0042",
		},
	))

	s.Register(TrackerHandler[string](tt))

	assert.Equal(t, s.Get(), nil)

	s.Set(ptr.Of("foo"))
	assert.Equal(t, s.Get(), ptr.Of("foo"))
	tt.WaitOrdered("add/foo")

	s.Set(nil)
	assert.Equal(t, s.Get(), nil)
	tt.WaitOrdered("delete/foo")

	s.Set(ptr.Of("bar"))
	assert.Equal(t, s.Get(), ptr.Of("bar"))
	tt.WaitOrdered("add/bar")

	s.Set(ptr.Of("bar2"))
	assert.Equal(t, s.Get(), ptr.Of("bar2"))

			actual := c.actual()
			g.Expect(actual).To(Equal(c.expected))
		})
	}
}

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

	schemas := collection.SchemasFor(emptyResource, structResource)
	g.Expect(schemas.Remove(structResource)).To(Equal(collection.SchemasFor(emptyResource)))
	g.Expect(schemas.Remove(emptyResource, structResource)).To(Equal(collection.SchemasFor()))