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

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

    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)

    void runAsWorkerThread(Runnable action) {
        action.run()
    }

    @Override
    void runAsUnmanagedWorkerThread(Runnable action) {
        action.run()
    }

    @Override
    Synchronizer newResource() {
        return new Synchronizer() {
            @Override
            void withLock(Runnable action) {
                action.run()
            }

            @Override

     * and the method will block until the locks are reacquired.
     */
    void withoutLock(ResourceLock lock, Runnable runnable);

    Synchronizer newResource();