NonResourceURLs []string
}

// Subject contains a reference to the object or user identities a role binding applies to.  This can either hold a direct API object reference,
// or a value for non-objects such as user and group names.
type Subject struct {
	// Kind of object being referenced. Values defined by this API group are "User", "Group", and "ServiceAccount".

		if err != nil {
			t.Fatalf("%s: failed to parse csr", id)
		}
		if err = csr.CheckSignature(); err != nil {
			t.Errorf("%s: csr signature is invalid", id)
		}
		if csr.Subject.Organization[0] != "MyOrg" {
			t.Errorf("%s: csr subject does not match", id)
		}
		if !strings.HasSuffix(string(csr.Extensions[0].Value), "test_ca.com") {
			t.Errorf("%s: csr host does not match", id)
		}
		if tc.csrOptions.ECSigAlg != "" {

 */

package org.gradle.ide.xcode.internal

import org.gradle.api.Project
import spock.lang.Specification
import spock.lang.Subject

class XcodePropertyAdapterTest extends Specification {
    def project = Mock(Project)

    @Subject
    def xcodePropertyAdapter = new XcodePropertyAdapter(project)

    def "getAction"() {
        expectProperty("org.gradle.internal.xcode.bridge.ACTION", "myaction")

import org.gradle.jvm.toolchain.internal.InstallationLocation
import org.gradle.test.fixtures.file.TestFile
import spock.lang.Specification
import spock.lang.Subject

class JvmInstallationProblemReporterTest extends Specification {
    @Subject
    def problemReporter = new JvmInstallationProblemReporter()
    def location = new TestFile("location")
    def logger = Mock(Logger)

    def "only reports problems once"() {

package org.gradle.internal.logging.serializer

import org.gradle.api.logging.LogLevel
import org.gradle.internal.logging.events.UserInputResumeEvent
import spock.lang.Subject

class UserInputResumeEventSerializerTest extends LogSerializerSpec {

    @Subject def serializer = new UserInputResumeEventSerializer()

    def "can serialize user input resume event"() {
        given:
        def event = new UserInputResumeEvent(123)

// and adds who information via Subject.
message ClusterRoleBinding {
  // Standard object's metadata.
  // +optional
  optional .k8s.io.apimachinery.pkg.apis.meta.v1.ObjectMeta metadata = 1;

  // Subjects holds references to the objects the role applies to.
  // +optional
  // +listType=atomic
  repeated Subject subjects = 2;

        }

        @Override
        public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
            return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()
                .put(ModelActionRole.Discover, AddProjectionsAction.of(subject, descriptor,
                    TypedModelProjection.of(
                        ModelTypes.modelSet(schema.getElementType()),

import java.lang.annotation.Target;

/**
 * Denotes that the {@link RuleSource} method rule carrying this annotation finalizes the rule subject.
 * <p>
 * Finalize rules execute after {@link Mutate} rules, but before {@link Validate} rules.
 * The first parameter of the rule is the rule subject, which is mutable for the duration of the rule.
 * <p>
 * Please see {@link RuleSource} for more information on method rules.
 */

package org.gradle.cache.internal

import org.gradle.util.ConcurrentSpecification
import spock.lang.Subject

import java.util.concurrent.atomic.AtomicInteger

import static org.gradle.test.fixtures.ConcurrentTestUtil.poll

class DefaultFileLockManagerAwaitableFileLockReleasedSignalTest extends ConcurrentSpecification {

    @Subject def signal = new DefaultFileLockManager.AwaitableFileLockReleasedSignal()

    def "can reuse signal"() {

 */
package org.gradle.internal.logging.serializer

import org.gradle.internal.operations.OperationIdentifier
import org.gradle.internal.logging.events.ProgressEvent
import spock.lang.Subject

@Subject(ProgressEventSerializer)
class ProgressEventSerializerTest extends LogSerializerSpec {
    private static final OperationIdentifier OPERATION_ID = new OperationIdentifier(1234L)