ant.withGroovyBuilder {
            "move"("file" to "${dir}/reports", "todir" to "${dir}/toArchive")
        }
    }
}
// end::move-example[]

// tag::delete-example[]
tasks.register<Delete>("myClean") {
    delete(buildDir)
}
// end::delete-example[]

// tag::delete-with-filter-example[]
tasks.register<Delete>("cleanTempFiles") {
    delete(fileTree("src").matching {
        include("**/*.tmp")
    })

    def dir = buildDir

    doLast {
        ant.move file: "${dir}/reports",
                 todir: "${dir}/toArchive"
    }
}
// end::move-example[]

// tag::delete-example[]
tasks.register('myClean', Delete) {
    delete buildDir
}
// end::delete-example[]

// tag::delete-with-filter-example[]
tasks.register('cleanTempFiles', Delete) {
    delete fileTree("src").matching {
        include "**/*.tmp"

        given:
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)
        dslDir.file("build").createDir().file("dummy.txt").touch()

        when:
        succeeds('myClean')

        then:
        dslDir.file('build').assertDoesNotExist()

        where:
        dsl << ['groovy', 'kotlin']
    }

    @UsesSample("files/misc")

    def "detects when a task removes the build directory #buildDir"() {
        buildFile << """
            apply plugin: 'base'

            project.buildDir = file("${buildDir}")

            task myClean(type: Delete) {
                delete buildDir
            }

            task producer {
                def outputFile = new File(buildDir, "some/file/in/buildDir/output.txt")

 * either express or implied. See the License for the specific language
 * governing permissions and limitations under the License.
 */
package org.codelibs.core.beans.util;

/**
 * @author higa
 */
public class MyBean {

    /**
     *
     */
    public String aaa;

    /**
     *
     */
    public String bbb;

        final MyBean myBean = new MyBean();
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final PropertyDesc propDesc = beanDesc.getPropertyDesc("aaa");
        propDesc.setValue(myBean, null);
    }

    /**
     * @throws Exception
     */
    @Test(expected = IllegalPropertyRuntimeException.class)
    public void testSetValue_notWritableWithField() throws Exception {
        final MyBean myBean = new MyBean();

        assertThat(ctor.getParameterTypes().length, is(1));
        assertThat(ctor.isPublic(), is(true));
        final MyBean myBean = ctor.newInstance("hoge");
        assertThat(myBean, is(notNullValue()));
        assertThat(myBean.s, is("hoge"));
    }

    /**
     */
    public static class MyBean {
        /** */
        public String s;

    @Test
    public void testFoo() throws Exception {
        final BeanDesc beanDesc = new BeanDescImpl(MyBean.class);
        final MethodDesc foo = beanDesc.getMethodDesc("foo");
        assertThat(foo, is(notNullValue()));
        assertThat(foo.getBeanDesc(), is(sameInstance(beanDesc)));
        assertThat(foo.getMethod(), is(MyBean.class.getMethod("foo")));
        assertThat(foo.getMethodName(), is("foo"));

        assertThat(parameterizedClassDesc.isParameterizedClass(), is(true));
        assertThat(parameterizedClassDesc.getRawClass(), is(sameClass(Class.class)));
        final MyBean myBean = new MyBean();
        aaa.setFieldValue(myBean, String.class);
        assertThat(aaa.getFieldValue(myBean), is(sameClass(String.class)));
    }

    /**
     * @throws Exception
     */
    @Test(expected = FieldNotStaticRuntimeException.class)

        assertNotNull(bean.myBean);
        assertNotSame(bean.myBean.getClass(), MySessionScopedBean.class);

        assertThrows(OutOfScopeException.class, () -> bean.myBean.getSession());

        sessionScope.enter();
        sessionScope.seed(Session.class, this.session);
        assertNotNull(bean.myBean.getSession());
        assertNotNull(bean.myBean.getAnotherBean());