private val routePlanner = FakeRoutePlanner()
  private val factory = routePlanner.factory
  private val taskFaker = routePlanner.taskFaker
  private val peer = MockHttp2Peer()

  /** The fake task runner prevents the cleanup runnable from being started.  */
  private val addressA = factory.newAddress("a")
  private val routeA1 = factory.newRoute(addressA)
  private val addressB = factory.newAddress("b")

    private final ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory;

    public DefaultExpectedRequests(ChainingHttpHandler.HandlerFactory<TrackingHttpHandler> factory) {
        this.factory = factory;
    }

    public TrackingHttpHandler create(WaitPrecondition previous) {
        return factory.create(previous);
    }

public class DefaultUnscopedCacheBuilderFactory implements UnscopedCacheBuilderFactory {
    private final CacheFactory factory;

    public DefaultUnscopedCacheBuilderFactory(CacheFactory factory) {
        this.factory = factory;
    }

    @Override
    public CacheBuilder cache(File baseDir) {
        return new DefaultCacheBuilder(factory, baseDir);
    }

            @Provides
            Integer createInteger(Factory<String> factory) {
                return factory.create().length()
            }

            @Provides
            Factory<String> createString(Callable<String> action) {
                return { action.call() } as Factory
            }

            @Provides
            Callable<String> createAction() {

     */
    int getMaxWorkerCount();

    /**
     * Runs a given {@link Factory} while the specified locks are being held, releasing
     * the locks upon completion.  Blocks until the specified locks can be obtained.
     */
    <T> T withLocks(Collection<? extends ResourceLock> locks, Factory<T> factory);

    /**
     * Runs a given {@link Runnable} while the specified locks are being held, releasing

        private final Factory<WritableArtifactCacheLockingAccessCoordinator> factory;
        private volatile WritableArtifactCacheLockingAccessCoordinator delegate;

        private LateInitWritableArtifactCacheLockingAccessCoordinator(Factory<WritableArtifactCacheLockingAccessCoordinator> factory) {
            this.factory = factory;
        }

        }
    }

    private JarTestFixture transformJar(TransformFactoryType factory, File originalJar) {
        def outputJar = testDir.file("transformed.jar")
        return new JarTestFixture(transform(factory, originalJar, outputJar), 'UTF-8', null, /* checkManifest */ false)
    }

    private TestFile transformDirectory(TransformFactoryType factory, File originalDir) {
        def outputDir = testDir.file("transformed")

     *
     * @param factory
     *            {@link SAXParserFactory}。{@literal null}であってはいけません
     * @return {@link SAXParser}の新しいインスタンス
     */
    public static SAXParser newSAXParser(final SAXParserFactory factory) {
        assertArgumentNotNull("factory", factory);

        try {
            return factory.newSAXParser();
        } catch (final ParserConfigurationException e) {

class DefaultArtifactFactoryTest {

    @Inject
    ArtifactFactory factory;

    @Test
    void testPropagationOfSystemScopeRegardlessOfInheritedScope() {
        Artifact artifact = factory.createDependencyArtifact(
                "test-grp", "test-artifact", VersionRange.createFromVersion("1.0"), "type", null, "system", "provided");
        Artifact artifact2 = factory.createDependencyArtifact(

class CachedStoreFactoryTest extends Specification {

    def "stores results"() {
        def factory = new CachedStoreFactory("some cache")

        def results1 = new Object()
        def results2 = new Object()

        def store1 = factory.createCachedStore("conf1")
        def store1b = factory.createCachedStore("conf1")
        def store2 = factory.createCachedStore("conf2")

        expect:
        store1.load(() -> results1) == results1