public boolean isExtensions() {
        return (getExtensions() != null) ? Boolean.parseBoolean(getExtensions()) : false;
    }
            ]]>
          </code>
        </codeSegment>
        <codeSegment>
          <version>4.0.0/4.0.99</version>
          <code>
            <![CDATA[
    public void setExtensions(boolean extensions) {
        setExtensions(String.valueOf(extensions));
    }

    /**

class ExtensionsStorageTest extends Specification {
    def storage = new ExtensionsStorage()
    def listExtension = Mock(List)
    def setExtension = Mock(Set)

    def "setup"() {
        storage.add(typeOf(List), "list", listExtension)
        storage.add(typeOf(Set), "set", setExtension)
    }

    def "has extension"() {
        expect:
        storage.hasExtension("list")
        !storage.hasExtension("not")
    }

                    throw new AssertionError(String.format("Unexpectedly failed to parse version of Scala Jar file: %s in %s", scalaLibraryJar, project));
                }

                String zincVersion = project.getExtensions().getByType(ScalaPluginExtension.class).getZincVersion().get();

                DefaultExternalModuleDependency compilerBridgeJar = getScalaBridgeDependency(scalaVersion, zincVersion);

        Provider<JavaToolchainSpec> toolchainOverride
    ) {
        JavaToolchainService service = project.getExtensions().getByType(JavaToolchainService.class);
        JavaPluginExtension extension = project.getExtensions().getByType(JavaPluginExtension.class);
        return toolchainOverride.orElse(extension.getToolchain())
            .flatMap(spec -> toolMapper.apply(service, spec));

        public JavaVersion apply(Project p) {
            return p.getExtensions().getByType(JavaPluginExtension.class).getSourceCompatibility();
        }
    };
    public static final Function<Project, JavaVersion> TARGET_COMPATIBILITY = new Function<Project, JavaVersion>() {
        @Override
        public JavaVersion apply(Project p) {
            return p.getExtensions().getByType(JavaPluginExtension.class).getTargetCompatibility();

                        for (SourceSet sourceSet : project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets()) {
                            task.dependsOn(sourceSet.getOutput().getDirs());
                        }
                    }
                });

                SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets();

        JacocoPluginExtension extension = project.getExtensions().create(PLUGIN_EXTENSION_NAME, JacocoPluginExtension.class, project, agent);
        extension.setToolVersion(DEFAULT_JACOCO_VERSION);
        final ReportingExtension reportingExtension = (ReportingExtension) project.getExtensions().getByName(ReportingExtension.NAME);

import java.util.Set;

public class LinkedResourcesCreator {
    public Set<Link> links(final Project project) {
        SourceSetContainer sourceSets = project.getExtensions().getByType(JavaPluginExtension.class).getSourceSets();
        EclipseClasspath classpath = project.getExtensions().getByType(EclipseModel.class).getClasspath();

        0 * scriptRunner._
    }

    void "configures a project object using script with imperative and inheritable code"() {
        given:
        def target = Mock(ProjectInternal) {
            getExtensions() >> Mock(ExtensionContainerInternal)
        }

        when:
        def configurer = factory.create(scriptSource, scriptHandler, targetScope, baseScope, true)
        configurer.apply(target)

                });
                rootProject.configure(scalaProjects, new Action<Project>() {
                    @Override
                    public void execute(final Project project) {
                        project.getExtensions().getByType(IdeaModel.class).getModule().getIml().withXml(new Action<XmlProvider>() {
                            @Override
                            public void execute(XmlProvider xmlProvider) {