return path.replace('.', '/') + ext;
    }

    /**
     * リソースパスを返します。
     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return リソースパス
     */
    public static String getResourcePath(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        return clazz.getName().replace('.', '/') + ".class";
    }

    /**
     * コンテキストクラスローダを返します。
     *

     *
     * @param clazz
     *            クラス。{@literal null}であってはいけません
     * @return クラス名
     */
    public static String getSimpleClassName(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (clazz.isArray()) {
            return getSimpleClassName(clazz.getComponentType()) + "[]";
        }
        return clazz.getName();
    }

    /**

      implements Predicate<T>, Serializable {
    private final Class<?> clazz;

    private InstanceOfPredicate(Class<?> clazz) {
      this.clazz = checkNotNull(clazz);
    }

    @Override
    public boolean apply(@ParametricNullness T o) {
      return clazz.isInstance(o);
    }

    @Override
    public int hashCode() {
      return clazz.hashCode();
    }

    @Override

      implements Predicate<T>, Serializable {
    private final Class<?> clazz;

    private InstanceOfPredicate(Class<?> clazz) {
      this.clazz = checkNotNull(clazz);
    }

    @Override
    public boolean apply(@ParametricNullness T o) {
      return clazz.isInstance(o);
    }

    @Override
    public int hashCode() {
      return clazz.hashCode();
    }

    @Override

        public <T extends Service> T getService(Class<T> clazz) throws NoSuchElementException {
            if (clazz == ArtifactCoordinateFactory.class) {
                return (T) new DefaultArtifactCoordinateFactory();
            } else if (clazz == VersionParser.class) {
                return (T) new DefaultVersionParser(new DefaultModelVersionParser(new GenericVersionScheme()));
            } else if (clazz == VersionRangeResolver.class) {

     *
     * @param clazz The implementation type
     * @return Instance of given implementation
     */
    private static <T> T newImplementation(final Class<T> clazz) {
        try {
            return clazz.newInstance();
        } catch (final Exception e) {
            throw new IllegalArgumentException("Cannot create instance of: " + clazz, e);
        } catch (final LinkageError e) {

    public <U> Injector bindInstance(Class<U> clazz, U instance) {
        Key<?> key = Key.of(clazz, ReflectionUtils.qualifierOf(clazz));
        Binding<U> binding = Binding.toInstance(instance);
        return doBind(key, binding);
    }

    @Override
    public Injector bindImplicit(Class<?> clazz) {
        Key<?> key = Key.of(clazz, ReflectionUtils.qualifierOf(clazz));
        if (clazz.isInterface()) {

        assertArgumentNotNull("type", type);
        assertArgumentNotNull("clazz", clazz);

        if (type instanceof Class) {
            return clazz.isAssignableFrom((Class<?>) type);
        }
        if (type instanceof ParameterizedType) {
            final ParameterizedType parameterizedType = ParameterizedType.class.cast(type);
            return isTypeOf(parameterizedType.getRawType(), clazz);
        }

     * {@link Logger}を返します。
     *
     * @param clazz
     *            ロガーのカテゴリとなるクラス。{@literal null}であってはいけません
     * @return {@link Logger}
     */
    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);
        if (logger == null) {

        }
    }

    def "remaps old-style string class literals"() {
        given:
        def clazz = IvySettings
        byte[] classData = clazz.getClassLoader().getResourceAsStream("${clazz.name.replace('.', '/')}.class").bytes

        when:
        def remapped = relocatedJarCreator.remapClass(clazz.name, classData)
        def cr = new ClassReader(remapped)
        def writer = new StringWriter()