if (services.containsKey(serviceType)) {
            return Cast.uncheckedNonnullCast(services.get(serviceType));
        }
        T t = delegate.get(serviceType);
        services.put(serviceType, t);
        return t;
    }

    @Override
    public synchronized <T> List<T> getAll(Class<T> serviceType) throws UnknownServiceException {

    @Inject
    EventSpyImpl(DefaultSessionFactory sessionFactory) {
        this.sessionFactory = sessionFactory;
    }

    @Override
    public void init(Context context) throws Exception {}

    @Override
    public void onEvent(Object arg) throws Exception {
        if (arg instanceof ExecutionEvent) {
            ExecutionEvent ee = (ExecutionEvent) arg;
            InternalMavenSession session =

            return result;
        }
    }

    private boolean hasContent(File file, String content) throws IOException {
        return file.exists() && Files.asCharSource(file, Charsets.UTF_8).readFirstLine().equals(content);
    }

    private void checkJavaIoTmpDirExists() throws IOException {
        @SuppressWarnings("deprecation")
        File dir = new File(SystemProperties.getInstance().getJavaIoTmpDir());

     * @param options possible parsing options, may be {@code null}
     * @return the parsed {@link Model}, never {@code null}
     * @throws ModelParserException if the model cannot be parsed
     */
    @Nonnull
    Model parse(@Nonnull Source source, @Nullable Map<String, ?> options) throws ModelParserException;

    /**
     * Locate and parse the model in the specified directory.

  @Synchronized fun writeSuccessCount(): Int = writeSuccessCount

  @Throws(IOException::class)
  fun size(): Long = cache.size()

  /** Max size of the cache (in bytes). */
  fun maxSize(): Long = cache.maxSize

  @Throws(IOException::class)
  override fun flush() {
    cache.flush()
  }

  @Throws(IOException::class)
  override fun close() {
    cache.close()
  }

    private NullOutputStream() {

    }

    @Override
    public void write(int b) throws IOException {
        // ignore
    }

    @Override
    public void write(byte[] b) throws IOException {
        // ignore
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        // ignore
    }

     * @return The source of the requested POM, never {@code null}.
     * @throws ModelResolverException If the POM could not be resolved from any configured repository.
     */
    @Nonnull
    default ModelSource resolveModel(
            @Nonnull Session session, @Nonnull Parent parent, @Nonnull AtomicReference<Parent> modified)
            throws ModelResolverException {
        return resolveModel(
                session,

            return session;
        }

        public BeanItf2 getAnotherBean() {
            return anotherBean;
        }

        public void throwException() throws TestException {
            throw new TestException();
        }
    }

    static class TestException extends Exception {}

        }
    }

    public void test_buildRedirectLocation() throws Exception {
        assertEquals("http://localhost/login.html", HcHttpClient.buildRedirectLocation("http://localhost/", "/login.html"));
    }

    // public void test_doGet_mt() throws Exception {
    // ExecutorService executorService = Executors.newFixedThreadPool(1);
    //
    // // HttpClient Parameters

        void execute() throws IOException;

        ReportMarginaliaAction DO_NOTHING = new ReportMarginaliaAction() {
            @Override
            public void execute() throws IOException {
                // Do nothing;
            }
        };
    }

    @FunctionalInterface
    public interface ReportAction<T> {
        void execute(T project) throws IOException;
    }