}

LogicalResult CopyAllowedUnregisteredAttrs(Operation* src, CallOp dst,
                                           const StringSet<>& registered) {
  for (auto& attr : src->getAttrs()) {
    StringRef attr_name = attr.getName().strref();
    // Skip the registered or optional attribute.
    if (registered.contains(attr_name) ||
        GetOptionalAttributes().contains(attr_name))
      continue;

    // Unregistered attribute.

    }

    def "actions do nothing when none registered"() {
        expect:
        r.fireObjectAdded("a")
        r.fireObjectRemoved("a")
    }

    def "nothing subscribed when no actions registered"() {
        expect:
        !r.isSubscribed(null)
        !r.isSubscribed(CharSequence)
        !r.isSubscribed(String)
    }

    def "actions are invoked in order registered"() {
        def action1 = Mock(Action)

 * ---------------------------------------------
 * JMORRIS2        <00>  UNIQUE      Registered
 * BILLING-NY      <00>  GROUP       Registered
 * JMORRIS2        <03>  UNIQUE      Registered
 * JMORRIS2        <20>  UNIQUE      Registered
 * BILLING-NY      <1E>  GROUP       Registered
 * JMORRIS         <03>  UNIQUE      Registered
 * 
 * MAC Address = 00-B0-34-21-FA-3B
 * </pre>
 * 
 * </blockquote>

 *
 * <p>
 *     The registered output {@link File}s will appear in the transformed variant in the order they were registered.
 * </p>
 *
 * @since 5.3
 */
@HasInternalProtocol
public interface TransformOutputs {
    /**
     * Registers an output directory.
     *
     * <p>
     *     For an <strong>absolute path</strong>, the location is registered as an output directory of the {@link TransformAction}.

        ComponentTypeRegistration registration = componentRegistrations.get(componentType);
        if (registration == null) {
            throw new IllegalArgumentException(String.format("Not a registered component type: %s.", componentType.getName()));
        }
        return registration;
    }

    private static class DefaultComponentTypeRegistration implements ComponentTypeRegistration {

        e.message == "Cannot add extension with name 'foo', as there is an extension already registered with that name."

        when:
        container.foo = 'other'

        then:
        IllegalArgumentException e2 = thrown()
        e2.message == "There's an extension registered with name 'foo'. You should not reassign it via a property setter."

        when:

     * </pre>
     *
     * @param name The name of the property to check for
     * @return {@code true} if a property has been registered with this name, otherwise {@code false}.
     */
    boolean has(String name);

    /**
     * Returns the value for the registered property with the given name.
     *
     * When using an extra properties extension from Groovy, you can also get properties via Groovy's property syntax.

        when:
        buildFile << """
            notifier.notify {
                println "failure is null: \${it.failure == null}"
            }
            // user logic registered _after_ listener registered
            gradle.projectsEvaluated {
                println "projects evaluated"
            }
        """

        run()

        then:
        output.contains("projects evaluated")

	// 10
	// 15
}

// interfaceEncode encodes the interface value into the encoder.
func interfaceEncode(enc *gob.Encoder, p Pythagoras) {
	// The encode will fail unless the concrete type has been
	// registered. We registered it in the calling function.

	// Pass pointer to interface so Encode sees (and hence sends) a value of
	// interface type. If we passed p directly it would see the concrete type instead.

    class Base {
        String value
    }

    class TestType extends Base {}

    class AnotherTestType extends Base {}

    def "trying to create an entity for which there is no factory registered results in an exception"() {
        given:
        instantiator.registerFactory(TestType, {})

        when:
        instantiator.create("foo", Integer)

        then: