}
	if err := s.AddGeneratedConversionFunc((*v1beta3.Subject)(nil), (*flowcontrol.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {
		return Convert_v1beta3_Subject_To_flowcontrol_Subject(a.(*v1beta3.Subject), b.(*flowcontrol.Subject), scope)
	}); err != nil {
		return err
	}
	if err := s.AddGeneratedConversionFunc((*flowcontrol.Subject)(nil), (*v1beta3.Subject)(nil), func(a, b interface{}, scope conversion.Scope) error {

public class NoInputsModelAction<T> extends AbstractModelActionWithView<T> {
    private final Action<? super T> configAction;

    public NoInputsModelAction(ModelReference<T> subject, ModelRuleDescriptor descriptor, Action<? super T> configAction) {
        super(subject, descriptor, Collections.<ModelReference<?>>emptyList());
        this.configAction = configAction;
    }

 */

package org.gradle.internal.featurelifecycle

import spock.lang.Specification
import spock.lang.Subject

import static SimulatedSingleMessageLogger.DIRECT_CALL
import static SimulatedSingleMessageLogger.INDIRECT_CALL
import static SimulatedSingleMessageLogger.INDIRECT_CALL_2

@Subject(StackTraceSanitizer)
class StackTraceSanitizerTest extends Specification {

 */

package org.gradle.scala.compile.internal

import org.gradle.api.tasks.scala.ScalaCompileOptions
import org.gradle.util.TestUtil
import spock.lang.Specification
import spock.lang.Subject

@Subject(ScalaCompileOptions)
class ScalaCompileOptionsTest extends Specification {

    def 'additional parameters are empty by default'() {

package org.gradle.performance.results

import org.gradle.performance.ResultSpecification
import org.gradle.performance.results.report.FlakinessScenarioPageGenerator
import spock.lang.Subject

class FlakinessScenarioPageGeneratorTest extends ResultSpecification {
    @Subject
    FlakinessScenarioPageGenerator generator = new FlakinessScenarioPageGenerator()
    StringWriter writer = new StringWriter()

    def "can generate cross version json data"() {

func groups(names ...string) []flowcontrol.Subject {
	ans := make([]flowcontrol.Subject, len(names))
	for idx, name := range names {
		ans[idx] = flowcontrol.Subject{
			Kind: flowcontrol.SubjectKindGroup,
			Group: &flowcontrol.GroupSubject{
				Name: name,
			},
		}
	}
	return ans
}

func users(names ...string) []flowcontrol.Subject {
	ans := make([]flowcontrol.Subject, len(names))

        val scriptHandler = mock<ScriptHandlerInternal>()
        val targetScope = mock<ClassLoaderScope>()

        // when:
        val subject = PluginRequestsHandler(pluginRequestApplicator, autoAppliedPluginHandler)
        subject.handle(initialRequests, scriptHandler, target, targetScope)

        // then:

    }

    @Override
    public Multimap<ModelActionRole, ModelAction> getActions(ModelReference<?> subject, ModelRuleDescriptor descriptor) {
        return ImmutableSetMultimap.<ModelActionRole, ModelAction>builder()
            .put(ModelActionRole.Discover, AddProjectionsAction.of(subject, descriptor, projections))
            .build();
    }

  // Name is the name of resource being referenced
  optional string name = 3;
}

// 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.
message Subject {
  // Kind of object being referenced. Values defined by this API group are "User", "Group", and "ServiceAccount".

 * limitations under the License.
 */

package org.gradle.api.internal.tasks.compile


import spock.lang.Specification
import spock.lang.Subject

import javax.tools.JavaCompiler

class JdkToolsTest extends Specification {
    @Subject
    JdkTools current = new JdkTools([])

    def "can get java compiler"() {
        def compiler = current.systemJavaCompiler

        expect: