private String nullify(String str) {
            return (str == null || str.isEmpty()) ? null : str;
        }

        @Override
        public Object getKey() {
            return metadata.toString();
        }

        @Override
        public String getRemoteFilename() {
            return metadata.getType();
        }

        @Override
        public String getLocalFilename(ArtifactRepository repository) {

	}
	return md.labelSet
}

func (md *MetricDescriptor) toPromName(namePrefix string) string {
	return prometheus.BuildFQName(namePrefix, "", string(md.Name))
}

func (md *MetricDescriptor) toPromDesc(namePrefix string, extraLabels map[string]string) *prometheus.Desc {
	return prometheus.NewDesc(
		md.toPromName(namePrefix),
		md.Help,
		md.VariableLabels, extraLabels,
	)
}

        return pluginDescriptor;
    }

    private String extractGroupId(PlexusConfiguration c) {
        return c.getChild("groupId").getValue();
    }

    private String extractArtifactId(PlexusConfiguration c) {
        return c.getChild("artifactId").getValue();
    }

    private String extractVersion(PlexusConfiguration c) {
        return c.getChild("version").getValue();
    }

        List<String> goals = session.getGoals();
        if (goals != null) {
            for (String goal : goals) {
                if (!isGoalSpecification(goal)) {
                    return true;
                }
            }
        }
        return false;
    }

    private boolean isBeforeOrAfterPhase(String task) {

    @Test
    void testReactorDependencyInjection() throws Exception {
        List<String> reactorOrder =
                getReactorOrder("lifecycle-participant-reactor-dependency-injection", InjectReactorDependency.class);
        assertEquals(Arrays.asList("parent", "module-b", "module-a"), reactorOrder);
    }

    private <T> List<String> getReactorOrder(String testProject, Class<T> participant) throws Exception {

                        "name": {
                            "title": "Name",
                            "type": "string",
                        },
                        "description": {
                            "title": "Description",
                            "anyOf": [{"type": "string"}, {"type": "null"}],
                        },
                        "price": {"title": "Price", "type": "number"},

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {

	}
	return keys
}

func (kvs KVS) String() string {
	var s strings.Builder
	for _, kv := range kvs {
		s.WriteString(kv.String())
		s.WriteString(KvSpaceSeparator)
	}
	return s.String()
}

// Merge environment values with on disk KVS, environment values overrides
// anything on the disk.
func Merge(cfgKVS map[string]KVS, envname string, defaultKVS KVS) map[string]KVS {
	newCfgKVS := make(map[string]KVS)

        customizeContainer(context, container);

        return container;
    }

    protected Set<String> collectExportedArtifacts(
            CoreExtensionEntry coreEntry, List<CoreExtensionEntry> extensionEntries) {
        Set<String> exportedArtifacts = new HashSet<>(coreEntry.getExportedArtifacts());
        for (CoreExtensionEntry extension : extensionEntries) {

                            "items": {
                                "anyOf": [{"type": "string"}, {"type": "integer"}]
                            },
                        },
                        "msg": {"title": "Message", "type": "string"},
                        "type": {"title": "Error Type", "type": "string"},
                    },
                },
                "HTTPValidationError": {