import org.gradle.api.problems.internal.ProblemCategory
import spock.lang.Specification

class ProblemCategoryTest extends Specification {

    def 'can be created with #namespace:#category'() {
        given:
        ProblemCategory pc = DefaultProblemCategory.create(namespace, category, subcategory as String[])

        expect:
        pc.namespace == namespace
        pc.category == category
        pc.subcategories == subcategory

    ValueSnapshot asSnapshot();

    /**
     * Returns an instance of T that is isolated from the original object and all other instances.
     * When T is mutable, a new instance is created on each call. When T is immutable, a new instance may or may not be created on each call. This may potentially be expensive.
     */
    @Nullable
    T isolate();

    /**

//	                       |            ReRegistration            |
//	                       | Socket created with same plugin name |
//	                       |                                      |
//	                       |                                      |
//	  Socket Created       v                                      +        Socket Deleted

# Create admission_control objects if defined before any other addon services. If the limits
# are defined in a namespace other than default, we should still create the limits for the
# default namespace.
while IFS=$'\n' read -r obj; do
  start_addon "${obj}" 100 10 default &
  log INFO "++ obj ${obj} is created ++"

import javax.annotation.Nullable;

/**
 * A {@link ClassLoaderFactory} that also stores the hash of each created classloader which is later retrievable via {@link #getClassLoaderClasspathHash(ClassLoader)}.
 */
public interface HashingClassLoaderFactory extends ClassLoaderFactory {
    /**
     * Creates a {@link ClassLoader} with the given parent and classpath. Use the given hash

import org.gradle.api.artifacts.component.ComponentIdentifier;

/**
 * Factory for {@link TransformUpstreamDependenciesResolver} that relies on the information provided to its {@code create} method.
 */
public interface TransformUpstreamDependenciesResolverFactory {
    /**
     * Creates a {@link TransformUpstreamDependenciesResolver} for the given {@code ComponentIdentifier} and {@code TransformChain}.
     *

	clienttest.MakeCRD(t, c, gvr.GatewayClass)

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

import org.gradle.api.provider.Property
import org.gradle.api.provider.SetProperty


/**
 * Creates a simple immutable [Named] object of the given type and name.
 *
 * @param T The type of object to create
 * @param name The name of the created object
 * @return the created named object
 *
 * @see [ObjectFactory.named]
 */
inline fun <reified T : Named> ObjectFactory.named(name: String): T =

		bi := BucketInfo{
			Name:    v.Name,
			Created: v.Created,
		}
		if vi, ok := deletedBuckets[v.Name]; ok {
			bi.Deleted = vi.Created
		}
		buckets = append(buckets, bi)
	}

	for _, v := range deletedBuckets {
		if _, ok := healBuckets[v.Name]; !ok {
			buckets = append(buckets, BucketInfo{
				Name:    v.Name,
				Deleted: v.Created,
			})
		}
	}

	return buckets, nil
}

	// Monitor should not have created canaries yet
	if !ensureNoChains(mfe) {
		t.Errorf("canary created while iptables blocked")
	}

	if err := waitForBlocked(mfe); err != nil {
		t.Errorf("failed waiting for monitor to fail creating canaries: %v", err)
	}

	mfe.blockIPTables(false)
	if err := waitForChains(mfe, canary, tables); err != nil {
		t.Errorf("failed to create iptables canaries: %v", err)
	}