this.session = copiedSession;
        final ProjectDependencyGraph dependencyGraph = getSession().getProjectDependencyGraph();
        nonTransitiveUpstreamProjects = dependencyGraph.getUpstreamProjects(getProject(), false);
        transitiveUpstreamProjects = dependencyGraph.getUpstreamProjects(getProject(), true);
    }

    public MavenSession getSession() {
        return session;
    }

    public MavenProject getProject() {

                    Object key = getPluginKey(element);
                    Plugin managedPlugin = managedPlugins.get(key);
                    if (managedPlugin != null) {
                        mergePlugin(element, managedPlugin, false, context);
                    }
                }
            }
        }

        @Override
        protected void mergePlugin_Executions(

		},
		{ // Expiration with both ExpiredObjectDeleteMarker and days
			inputXML: `<Expiration>
                                    <Days>3</Days>
			            <ExpiredObjectDeleteMarker>false</ExpiredObjectDeleteMarker>
                                    </Expiration>`,
			expectedErr: errLifecycleInvalidDeleteMarker,
		},
		{ // Expiration with a valid number of days and ExpiredObjectAllVersions

	}

	runtimeTests := []errtest{
		{"TEXT", "foo<ABIInternal>(SB),0", "TEXT \"foo\": ABIInternal requires NOSPLIT"},
	}

	testcats := []struct {
		allowABI bool
		tests    []errtest
	}{
		{
			allowABI: false,
			tests:    nonRuntimeTests,
		},
		{
			allowABI: true,
			tests:    runtimeTests,
		},
	}

	// Note these errors should be independent of the architecture.
	// Just run the test with amd64.

            if (!isInternal(current)) {
                // there's another public super class which contains target method
                // it would be reported somewhere else
                return false
            }
        }

        // I'm the top public class which contains target method
        return true
    }

    private boolean containsMethod(CtClass c, CtMethod method) {

          <reportSet>
            <id>default-inherited</id>
            <reports>
              <report>to-be-inherited</report>
            </reports>
          </reportSet>
          <!-- reportSet with inherited=false is not here -->
        </reportSets>
      </plugin>
    </plugins>
  </reporting>

            Parameter parameter,
            PlexusConfiguration pomConfiguration,
            ExpressionEvaluator expressionEvaluator) {
        PlexusConfiguration config = pomConfiguration.getChild(parameter.getName(), false);

        if (isValueSet(config, expressionEvaluator)) {
            pluginValidationManager.reportPluginMojoValidationIssue(
                    PluginValidationManager.IssueLocality.INTERNAL,

         */
        Throwable error) {

    /**
     * Determines if the request was processed successfully.
     *
     * @return true if no error occurred during processing (error is null), false otherwise
     */
    public boolean isSuccess() {
        return error == null;
    }

                                "title": "Item Id",
                                "type": "integer",
                            },
                        },
                        {
                            "required": False,
                            "schema": {
                                "anyOf": [{"type": "string"}, {"type": "null"}],
                                "title": "Q",
                            },

}

// IsBOSH returns true if minio is deployed from a bosh package
func IsBOSH() bool {
	// "/var/vcap/bosh" exists in BOSH deployed instance.
	_, err := os.Stat("/var/vcap/bosh")
	if osIsNotExist(err) {
		return false
	}

	// Log error, as we will not propagate it to caller
	internalLogIf(GlobalContext, err)

	return err == nil
}

// MinIO Helm chart uses DownwardAPIFile to write pod label info to /podinfo/labels