val knownSubprojectDirs = model.subprojects.subprojects.map { File("../", it.path) }
        subProjectFolderList().forEach {
            assertTrue(
                it in knownSubprojectDirs,
                "Not defined: $it",
            )
        }
    }

    @Test
    fun uuidsAreUnique() {
        val uuidList = model.stages.flatMap { it.functionalTests.map { ft -> ft.uuid } }

	CacheControl string

	// Specify object storage class
	StorageClass string

	ReplicationStatusInternal string
	ReplicationStatus         replication.StatusType
	// User-Defined metadata
	UserDefined map[string]string

	// User-Defined object tags
	UserTags string

	// List of individual parts, maximum size of upto 10,000
	Parts []ObjectPartInfo `json:"-"`

    JAVACMD="$JAVA_HOME/jre/sh/java"
  else
    JAVACMD="$JAVA_HOME/bin/java"

    if [ ! -x "$JAVACMD" ] ; then
      echo "The JAVA_HOME environment variable is not defined correctly, so Apache Maven cannot be started." >&2
      echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" does not exist." >&2
      exit 1
    fi
  fi
else

 * the artifact will be used: type, scope and obligation (whether the dependency is optional or mandatory).
 * The version and the obligation may not be defined precisely.</p>
 *
 * <p>{@link org.apache.maven.api.Dependency} instances represent artifacts in the repository
 * that are dependencies of the project.

	"github.com/minio/mux"
	"github.com/minio/pkg/v3/policy"
)

// Data types used for returning dummy tagging XML.
// These variables shouldn't be used elsewhere.
// They are only defined to be used in this file alone.

// GetBucketWebsite  - GET bucket website, a dummy api
func (api objectAPIHandlers) GetBucketWebsiteHandler(w http.ResponseWriter, r *http.Request) {
	ctx := newContext(r, w, "GetBucketWebsite")

            <type>Repository</type>
            <multiplicity>*</multiplicity>
          </association>
          <comment><![CDATA[ This may be removed or relocated in the near
            future. It is undecided whether plugins really need a remote
            repository set of their own. ]]></comment>
        </field>
      </fields>
    </class>
    <class>
      <name>Activation</name>

 their source trees set up in the same way as their colleagues.

 here's what I do currently in the netbeans part of the mavenide project to
 find the relevant subprojects/sibling projects. I check if the user has
 defined the maven.multiproject.includes property in any of his properties
 files for the current project. if yes. then I'm able to find projects that
 can be offered to be opened together with the current project.

So, a Python class is also a **callable**.

Then, in **FastAPI**, you could use a Python class as a dependency.

What FastAPI actually checks is that it is a "callable" (function, class or anything else) and the parameters defined.

If you pass a "callable" as a dependency in **FastAPI**, it will analyze the parameters for that "callable", and process them in the same way as the parameters for a *path operation function*. Including sub-dependencies.

            semantics.
            <p>In general, this is a properties format: {@code <name>value</name>} with per-toolchain
            defined properties names.
          </description>
        </field>
      </fields>
      <codeSegments>
        <codeSegment>
          <version>1.2.0+</version>

- plugin execution error due to something that is not expected to go wrong (the compiler executable missing)
- asking to use a plugin for which you do not have a version defined - tools to easily select versions
- goal not found in a plugin (probably could list the ones that are)

 */

// PluginNotFoundException, PluginResolutionException, PluginDescriptorParsingException,