clazz.assertTestCaseStderr("m1", is("constructor err\nbeforeTest err\nm1 err\nafterTest err\n"))
        clazz.assertTestCaseStderr("m2", is("constructor err\nbeforeTest err\nm2 err\nafterTest err\n"))
        clazz.assertTestCaseStdout("m1", is("constructor out\nbeforeTest out\nm1 out\nafterTest out\n"))
        clazz.assertTestCaseStdout("m2", is("constructor out\nbeforeTest out\nm2 out\nafterTest out\n"))

    }

    def "cannot be instantiated with null project constructor parameter value"() {
        when:
        new DefaultLibraryComponentSelector(null, 'myLib')

        then:
        Throwable t = thrown(AssertionError)
        t.message == 'project path cannot be null or empty'
    }

    def "cannot be instantiated with empty project constructor parameter value"() {
        when:

        myProperty.set("Hello, Gradle!")
        println(myProperty.get())
    }
}
// end::object-factory[]

// tag::object-factory-inject[]
abstract class MyObjectFactoryTask
@Inject constructor(private var objectFactory: ObjectFactory) : DefaultTask() {

    @TaskAction
    fun doTaskAction() {
        val outputDirectory = objectFactory.directoryProperty()

public interface ITaskFactory {
    ITaskFactory createChild(ProjectInternal project, InstantiationScheme instantiationScheme);

    /**
     * @param constructorArgs null == do not invoke constructor, empty == invoke constructor with no args, non-empty = invoke constructor with args
     */
    <S extends Task> S create(TaskIdentity<S> taskIdentity, @Nullable Object[] constructorArgs);

    }

    @Override
    public void add(Method method, String role, String problem) {
        problems.add(method, role, problem);
    }

    @Override
    public void add(Constructor<?> constructor, String problem) {
        problems.add(constructor, problem);
    }

    @Override
    public void add(MethodRuleDefinition<?, ?> method, String problem) {
        problems.add(method, problem);
    }

    @Override

fun x(): Int fromClass BB

fun y() fromClass BB

val c: Int fromClass BB

constructor(a: A<Int>) fromClass BB

        }
    }

    private
    val reportedMembers = listOf(
        "Class" to "AddedClass"
    ) + reportedMembersFor("AddedClass") + listOf(
        "Constructor" to "AddedClass(java.lang.String)",
        "Constructor" to "AddedClass()",
        "Class" to "AddedEnum",
        "Field" to "FOO"
    ) + reportedMembersFor("AddedEnum", isEnum = true) + listOf(

    }

    @Override
    public void add(Method method, String problem) {
        add(method, null, problem);
    }

    @Override
    public void add(Constructor<?> constructor, String problem) {
        problems.add(constructor, problem);
    }

    @Override
    public void add(String property, String problem) {
        problems.add("Property '" + property + "' is not valid: " + problem);
    }

struct LoggableOperation {
  mlir::Operation& v;
  // NOLINTNEXTLINE(google-explicit-constructor)
  LoggableOperation(mlir::Operation& v) : v(v) {}
};
std::ostream& operator<<(std::ostream& o, const LoggableOperation& op);

struct LoggableAttribute {
  mlir::Attribute& v;
  // NOLINTNEXTLINE(google-explicit-constructor)
  LoggableAttribute(mlir::Attribute& v) : v(v) {}
};

abstract class GreetingTask extends DefaultTask {
    // tag::convention-callsites-from-constructor[]
    // setting convention from constructor
    @Input
    abstract Property<String> getGuest()

    GreetingTask() {
        guest.convention("person2")
    }
    // end::convention-callsites-from-constructor[]

    // tag::convention-callsites-from-declaration[]
    // setting convention from declaration