withProblem("Task `:inc:sub:broken` of type `org.gradle.api.DefaultTask`: cannot serialize object of type 'org.gradle.api.internal.project.DefaultProject', a subtype of 'org.gradle.api.Project', as these are not supported with the configuration cache.")
            problemsWithStackTraceCount = 2
        }
    }

    def "does not report problems in tasks that produce plugins"() {

        n1.isImmutable()
        def state = n1.unpackState()
        state == "a"

        def n2 = factory.fromState(Named, state)
        n2.is(n1)
    }

    def "creates instance of subtype of Named"() {
        expect:
        def n1 = factory.named(CustomNamed, "a")
        def n2 = factory.named(CustomNamed, "b")

        n1.is(n1)
        !n1.is(n2)

        n1.name == "a"

     * this method succeeds, it always returns a reference to this {@code ModelType} object.
     *
     * @throws ClassCastException if this cannot be cast as the subtype of the given type.
     * @throws IllegalStateException if this is a wildcard.
     * @throws IllegalArgumentException if the given type is a wildcard.
     */

        component.projectPath == componentId.projectPath
        component.displayName == "SampleComponent '$componentId.name'"
        component.toString() == component.displayName
    }

    def "create fails if subtype does not have a public no-args constructor"() {

        when:
        create(ConstructedComponent, MyConstructedComponent)

        then:
        def e = thrown ModelRuleExecutionException

 * registered with that name, it will be automatically assigned to the property when the
 * task is created.
 * </p>
 * <p>
 * It is an error to apply this annotation to a property whose type is not a subtype of {@link BuildService}.
 * </p>
 *
 * @since 8.0
 */
@Documented
@Retention(RetentionPolicy.RUNTIME)
@Target({ElementType.METHOD, ElementType.FIELD})
@Incubating
public @interface ServiceReference {

 *
 * <strong>Property annotation inheritance</strong>
 *
 * <p>
 * Property annotations are inherited from super-types on a per-category basis: subtypes can override each super-type annotation category separately.
 * If a subtype doesn't override a super-type defined category, the corresponding annotation in that category gets inherited.
 * Subtypes can mark methods to be ignored by using an ignore annotation.

        if (!baseType.isAssignableFrom(type)) {
            String message = String.format("Cannot register a factory for type %s because it is not a subtype of container element type %s.", type.getSimpleName(), baseType.getSimpleName());
            throw new IllegalArgumentException(message);
        }
        if (factories.containsKey(type)) {

 * the service to tasks.</p>
 *
 * <p>A service implementation may optionally take parameters. To do this create a subtype of {@link BuildServiceParameters} and declare this
 * type as the type parameter to the service implementation.</p>
 *

		return errInvalidDeleteReplicationStatus
	}
	return nil
}

// UnmarshalXML - decodes XML data.
func (d *DeleteReplication) UnmarshalXML(dec *xml.Decoder, start xml.StartElement) (err error) {
	// Make subtype to avoid recursive UnmarshalXML().
	type deleteReplication DeleteReplication
	drep := deleteReplication{}

	if err := dec.DecodeElement(&drep, &start); err != nil {
		return err
	}
	if len(drep.Status) == 0 {

   * Returns the value the specified class is mapped to, or {@code null} if no entry for this class
   * is present. This will only return a value that was bound to this specific class, not a value
   * that may have been bound to a subtype.
   */
  @CheckForNull
  <T extends @NonNull B> T getInstance(Class<T> type);

  /**
   * Maps the specified class to the specified value. Does <i>not</i> associate this value with any
   * of the class's supertypes.