filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "foo.txt", methodInside("Bar"), methodInside("Bar"))

        then:
        !result.fullRebuildCause
    }

    def "packages are valid originating elements"() {
        when:
        filer.createSourceFile("Foo", pkg("fizz"))
        filer.createResource(StandardLocation.SOURCE_OUTPUT, "", "foo.txt", pkg("fizz"))

    def "resources with same path but different location are distinct"() {
        when:
        filer.createResource(StandardLocation.SOURCE_OUTPUT,        "com.enterprise.software", "foo.txt", type("A"))
        filer.createResource(StandardLocation.CLASS_OUTPUT,         "com.enterprise.software", "foo.txt", type("A"))
        filer.createResource(StandardLocation.NATIVE_HEADER_OUTPUT, "com.enterprise.software", "foo.txt", type("A"))

        then:

    }

    @Override
    public final FileObject createResource(JavaFileManager.Location location, CharSequence pkg, CharSequence relativeName, Element... originatingElements) throws IOException {
        // Prefer having javac validate the location over us, by calling it first.
        FileObject resource = delegate.createResource(location, pkg, relativeName, originatingElements);

        outputLocations = locations
        this
    }

    String getGeneratorCode() {
        def outputs = outputLocations.collect { """
        resourceFile = filer.createResource($it, \"\", resourceName${providesNoOriginatingElements ? '' : ', element'});
        writer = resourceFile.openWriter();
        try {
            writer.write("We did it.");
        } finally {

		Name:             "name1",
		Namespace:        "ns1",
		GroupVersionKind: r.GroupVersionKind(),
	}
	createResource(t, store, r, configMeta1)

	configMeta2 := config.Meta{
		Name:             "name2",
		Namespace:        "ns2",
		GroupVersionKind: r.GroupVersionKind(),
	}
	createResource(t, store, r, configMeta2)

	retry.UntilSuccessOrFail(t, func() error {
		l := store.List(r.GroupVersionKind(), "")

    TFConcreteFunction* create_resource = nullptr;

    // Check all the functions associated with the resource have already been
    // initialized in `revived`
    if (resource_revival_state.create_resource != nullptr) {
      create_resource = revived->concrete_functions.Find(
          resource_revival_state.create_resource->node_id);
      if (create_resource == nullptr) {

                    } finally {
                        writer.close();
                    }
                }
                if (roundEnv.processingOver()) {
                    FileObject resourceFile = filer.createResource($resourceLocation, "", "ServiceRegistryResource.txt", allElements.toArray(new Element[0]));
                    Writer writer = resourceFile.openWriter();
                    try {

			return m.createResource(m.RESTClient, m.Resource, namespace, obj, options)
		}
		if version != "" {
			if err := metadataAccessor.SetResourceVersion(obj, ""); err != nil {
				return nil, err
			}
		}
	}

	return m.createResource(m.RESTClient, m.Resource, namespace, obj, options)
}

        messager.printMessage(Diagnostic.Kind.ERROR, "Failed to generate source file " + className, element);
    }
"""
        def resourceCode = writeResources ? """
    try {
        FileObject resourceFile = filer.createResource($resourceLocation, "", className + "Resource.txt", ${withMultipleOriginatingElements ? "elements.toArray(new Element[0])" : "element"});
        Writer writer = resourceFile.openWriter();
        try {

func CreateNamedResource(r rest.NamedCreater, scope *RequestScope, admission admission.Interface) http.HandlerFunc {
	return createHandler(r, scope, admission, true)
}

// CreateResource returns a function that will handle a resource creation.
func CreateResource(r rest.Creater, scope *RequestScope, admission admission.Interface) http.HandlerFunc {
	return createHandler(&namedCreaterAdapter{r}, scope, admission, false)
}