}

            return invokeOpaqueMethod(metaClass, name, arguments);
        }

        @Nullable
        protected MetaMethod lookupMethod(MetaClass metaClass, String name, Class[] arguments) {
            return metaClass.pickMethod(name, arguments);
        }

        protected DynamicInvokeResult invokeOpaqueMethod(MetaClass metaClass, String name, Object[] arguments) {

        }
    }

    //region implementations delegating to adaptee
    @Override
    public MetaClass getAdaptee() {
        return adaptee;
    }

    @Override
    public void setAdaptee(MetaClass metaClass) {
        adaptee = metaClass;
    }

    @Override
    public synchronized void initialize() {
        this.adaptee.initialize();
    }

            MethodVisitor methodVisitor = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC, "getMetaClass", RETURN_META_CLASS, null, null);
            methodVisitor.visitCode();

            // if (this.metaClass != null) { return this.metaClass; }
            methodVisitor.visitVarInsn(Opcodes.ALOAD, 0);
            methodVisitor.visitFieldInsn(Opcodes.GETFIELD, className, META_CLASS_FIELD, META_CLASS_TYPE.getDescriptor());

        this.stderr = stderr
        this.stdout = stdout
        this.dist = dist
        this.useSeparateDaemonBaseDir = DefaultGradleConnector.metaClass.respondsTo(null, "daemonBaseDir")
        this.gradleUserHomeDir = context.gradleUserHomeDir
        this.daemonBaseDir = context.daemonBaseDir
        this.requiresDaemon = !GradleContextualExecuter.embedded

 *          that this closure is now in the scope of an instrumented call, so changing its delegate must be reflected in updating the new delegate's
 *          metaclass for call interception.
 *     <li> Overrides {@link Closure#setDelegate}, adding a call to {@link InstrumentedGroovyMetaClassHelper#addInvocationHooksInClosureDispatchObject} with

            class SomeTask extends DefaultTask {
            }
            class SomeExtension {
            }

            SomeTask.metaClass.p1 = 12
            SomeTask.metaClass.m1 = { -> "m1" }
            SomeExtension.metaClass.p2 = 10
            SomeExtension.metaClass.m2 = { String p -> p }

            task t(type: SomeTask)
            extensions.add("e", SomeExtension)

            assert t.p1 == 12

        for (Field field : type.getDeclaredFields()) {
            if (Modifier.isStatic(field.getModifiers()) || (GroovyObject.class.isAssignableFrom(type) && field.getName().equals("metaClass"))) {
                continue;
            }
            collector.add(field, "A Named implementation class must not define any instance fields.");
        }
    }

        assertEquals("Microsoft Office Word", extractData.getValues("extended-properties:Application")[0]);
        assertEquals("sugaya", extractData.getValues("meta:last-author")[0]);
        assertEquals("太郎", extractData.getValues("dc:creator")[0]);
        assertEquals("かいしゃ", extractData.getValues("extended-properties:Company")[0]);