}
                    }
                }
            }
        }

        then:
        noExceptionThrown()
    }

    def "withProperties(Map) and withProperties are never run concurrently"() {
        final int threadCount = 100
        def id = UUID.randomUUID().toString()

        when:
        async {
            threadCount.times { i ->

 *       //and after gradle build information is merged
 *       whenMerged { jdt
 *         //you can tinker with the {@link Jdt} here
 *       }
 *
 *       //withProperties allows addition of properties not currently
 *       //modeled by Gradle
 *       withProperties { properties ->
 *           //you can tinker with the {@link java.util.Properties} here
 *       }
 *     }
 *   }
 * }
 * </pre>
 */

     *
     * @param closure The closure to execute when the Properties have been created.
     */
    public void withProperties(Closure closure) {
        withProperties(new ClosureBackedAction<Properties>(closure, Closure.OWNER_FIRST));
    }

    /**
     * Adds an action to be called when the file has been created.

        <title>Methods</title>
        <table>
            <thead>
                <tr>
                    <td>Name</td>
                </tr>
            </thead>
            <tr>
                <td>withProperties</td>
            </tr>
        </table>
    </section>

    private String displayName;

    public DefaultCacheBuilder(CacheFactory factory, File baseDir) {
        this.factory = factory;
        this.baseDir = baseDir;
    }

    @Override
    public CacheBuilder withProperties(Map<String, ?> properties) {
        this.properties = properties;
        return this;
    }

    @Override
    public CacheBuilder withDisplayName(String displayName) {
        this.displayName = displayName;

        it.targetCompatibility = JavaVersion.toVersion('1.1')
      }
      withProperties {
        hooks << 'withProperties'
        it.dummy = 'testValue'
      }
    }
  }
}

eclipseJdt.doLast() {
  assert hooks == ['beforeMerged', 'whenMerged', 'withProperties']
}
        """
        when:
        run "eclipse"
        def jdt = parseJdtFile()
        then:

        1 * cacheFactory.open(sharedCacheDir, null, [:], mode(Shared), _, NO_CLEANUP) >> cache
        0 * cacheFactory._
    }

    void createsGlobalCacheWithProperties() {
        when:
        builder.withProperties(properties).open()

        then:
        1 * cacheFactory.open(sharedCacheDir, null, properties, mode(Shared), _, NO_CLEANUP) >> cache
    }

    void canSpecifyInitializerActionForDirectoryCache() {

        and:
        propertyNames(new WithProperties()) == ['class', 'metaClass', 'prop1', 'prop2', 'something', 'somethingElse', 'writeOnly'] as Set
    }

    def "read property"() {
        expect:

     * empty map.
     *
     * @param properties additional properties for the cache.
     * @return this
     */
    CacheBuilder withProperties(Map<String, ?> properties);

    /**
     * Specifies the display name for this cache. This display name is used in logging and error messages.
     */
    CacheBuilder withDisplayName(String displayName);

        then:
        1 * propertiesMerger.getTransformer()

        when: "configure jdt properties"
        model.jdt.file.withProperties(propertiesAction)

        then:
        1 * propertiesTransformer.addAction(propertiesAction)
    }

    def "can configure wtp with Actions"() {
        given: