List<T> newResources = null;
        if (resources != null) {
            for (int i = 0; i < resources.size(); i++) {
                T resource = resources.get(i);
                T newResource = mapper.apply(resource);
                if (newResource != null) {
                    if (newResources == null) {
                        newResources = new ArrayList<>(resources);
                    }

        List<T> newResources = null;
        if (resources != null) {
            for (int i = 0; i < resources.size(); i++) {
                T resource = resources.get(i);
                T newResource = mapper.apply(resource);
                if (newResource != null) {
                    if (newResources == null) {
                        newResources = new ArrayList<>(resources);
                    }

		}
	}
	added := sets.NewString()
	for newResource := range newResources {
		if _, ok := oldResources[newResource]; !ok {
			added.Insert(fmt.Sprintf("%+v", newResource))
		}
	}
	return fmt.Sprintf("added: %v, removed: %v", added.List(), removed.List())
}

// waitForStopOrTimeout returns a stop channel that closes when the provided stop channel closes or when the specified timeout is reached

func printDiff(oldResources, newResources map[schema.GroupVersionResource]struct{}) string {
	removed := sets.NewString()
	for oldResource := range oldResources {
		if _, ok := newResources[oldResource]; !ok {
			removed.Insert(fmt.Sprintf("%+v", oldResource))
		}
	}
	added := sets.NewString()
	for newResource := range newResources {
		if _, ok := oldResources[newResource]; !ok {

				policy.NewActionSet(policy.GetBucketLocationAction),
				policy.NewResourceSet(policy.NewResource("mybucket")),
				condition.NewFunctions(),
			),
			policy.NewBPStatement("",
				policy.Allow,
				policy.NewPrincipal("*"),
				policy.NewActionSet(policy.PutObjectAction),
				policy.NewResourceSet(policy.NewResource("mybucket/myobject*")),
				condition.NewFunctions(),
			),
		},
	}

    abstract CrossVersionPerformanceTestRunner getRunner()

    WebAppContext createContext() {
        def context = new WebAppContext()
        context.setContextPath("/")
        context.setBaseResource(Resource.newResource(repoDir.getAbsolutePath()))
        context
    }

    void startServer() {
        try {
            serverPort = AvailablePortFinder.getNextAvailable(5000)
            server = new Server(serverPort)

	// case "http/json": // unsupported by library
	default:
		return nil, fmt.Errorf("unsupported otlp protocol %v", proto)
	}
	return otlptrace.New(context.Background(), c)
}

// newResource returns a resource describing this application.
func newResource() *resource.Resource {
	r, _ := resource.Merge(
		resource.Default(),
		resource.NewWithAttributes(
			semconv.SchemaURL,
			// TODO: consider adding attributes here.

var G int

type memResource struct {
	x *int
}

func (m *memResource) initialize(*int) (res *int, err error) {
	return nil, nil
}

func (m *memResource) teardown() {
}

func NewResource(cfg *aconfig.Config) *bresource.Resource[*int] {
	res := &memResource{
		x: &G,
	}

	return bresource.New("Mem", res.initialize, bresource.ResConfig{
		// We always would want to retry the Memcache initialization.

    public <T extends StateTransitionController.State> StateTransitionController<T> newController(DisplayName displayName, T initialState) {
        return new StateTransitionController<>(displayName, initialState, workerLeaseService.newResource());
    }

type Module struct {
	cfg  *aconfig.Config
	err  error
	last any
}

//go:noinline
func TD() {
}

func (m *Module) Configure(x string) error {
	if m.err != nil {
		return m.err
	}
	res := cmem.NewResource(m.cfg)
	m.last = res

	return nil
}

func (m *Module) Blurb(x string, e error) bool {
	res, ok := m.last.(*bresource.Resource[*int])
	if !ok {
		panic("bad")
	}
	return bresource.Should(res, e)