return new InvalidUserDataException(String.format("The task '%s' (%s) is not a subclass of the given type (%s).", name, actual.getCanonicalName(), expected.getCanonicalName()));
    }

    @Override
    public TaskProvider<T> named(String name) throws UnknownTaskException {
        return (TaskProvider<T>) super.named(name);
    }

    @Override

    }

    /**
     * Output: The ${task} task has been deprecated.
     */
    @CheckReturnValue
    public static DeprecationMessageBuilder.DeprecateTask deprecateTask(String task) {
        return new DeprecationMessageBuilder.DeprecateTask(task);
    }

    /**

        return outputStream -> {
            Properties properties = new Properties();
            properties.setProperty(BUILD_INVOCATION_ID_KEY, currentBuildInvocationId);
            properties.setProperty(TYPE_KEY, workType.getCanonicalName());
            properties.setProperty(IDENTITY_KEY, identity);
            properties.setProperty(CACHE_KEY, buildCacheKey.toString());

                throw new ContainerNotAvailableException(clazz.getCanonicalName(), e);
            }
            throw new ContainerNotAvailableException(clazz.getCanonicalName());
        } catch (final ComponentNotFoundException | AutoBindingFailureException e) {
            if (componentMap.containsKey(clazz.getCanonicalName())) {
                return (T) componentMap.get(clazz.getCanonicalName());
            }
            throw e;
        }

    }

    protected static Splitter nameSplitter() {
        return Splitter.on(SEPARATOR_PATTERN);
    }

    protected void addImport(Class<?> clazz) throws IOException {
        addImport(clazz.getCanonicalName());
    }

    protected void addImport(String clazz) throws IOException {
        writeLn("import " + clazz + ";");
    }

    protected void writeLn() throws IOException {
        writer.write(ln);

    }

    private static boolean isAnnotationOfType(AnnotationMirror annotation, Class<? extends Annotation> type) {
        return annotation.getAnnotationType().toString().equals(type.getCanonicalName());
    }

 */
public class PropertyResourceBundleFallbackCharset extends Charset {

    public PropertyResourceBundleFallbackCharset() {
        super(PropertyResourceBundleFallbackCharset.class.getCanonicalName(), new String[0]);
    }

    @Override
    public boolean contains(Charset charset) {
        return false;
    }

    @Override
    public CharsetDecoder newDecoder() {

            try {
                client.close();
            } catch (final Exception e) {
                logger.warn("Faild to close {}.", client.getClass().getCanonicalName(), e);
            }
        });
    }

        Compilation compilation = compile(givenSource)

        then:
        def capability = type.getInterceptorMarkerInterface().getCanonicalName() - (type.getInterceptorMarkerInterface().package.name + ".")
        def factoryCapability = type.getInterceptorFactoryMarkerInterface().getCanonicalName() - (type.getInterceptorFactoryMarkerInterface().package.name + ".")
        def expectedJvmInterceptors = source """
            package my;

     * @param <T> the type of the attribute
     * @return an attribute with the given name and type
     */
    public static <T> Attribute<T> of(Class<T> type) {
        return of(WordUtils.uncapitalize(type.getCanonicalName()), type);
    }

    private Attribute(String name, Class<T> type) {
        this.name = name;
        this.type = type;
        int hashCode = name.hashCode();