Metadata repoMetadata = metadata.getMetadata();
        String version = null;
        if (repoMetadata != null && repoMetadata.getVersioning() != null) {
            version = constructVersion(repoMetadata.getVersioning(), artifact.getBaseVersion());
        }

        if (version == null) {
            // use the local copy, or if it doesn't exist - go to the remote repo for it

def test_optional_str_schema(path: str):
    assert app.openapi()["paths"][path]["get"]["parameters"] == [
        {
            "required": False,
            "schema": {
                "anyOf": [{"type": "string"}, {"type": "null"}],
                "title": "P",
            },
            "name": "p",
            "in": "header",
        }
    ]


@pytest.mark.parametrize(
    "path",

        SessionData sessionDataMock = Mockito.mock(SessionData.class);
        when(systemSessionMock.getData()).thenReturn(sessionDataMock);

        new ConsumerPomArtifactTransformer((session, project, src) -> null)
                .injectTransformedArtifacts(systemSessionMock, emptyProject);

        assertTrue(emptyProject.getAttachedArtifacts().isEmpty());
    }

    @Test
    void testDeployBuildPomEnabledByDefault() {

    /**
     * Gets the policy that applies to this metadata regarding the specified repository.
     *
     * @param repository The repository for which to determine the policy, must not be {@code null}.
     * @return The policy, never {@code null}.
     */
    ArtifactRepositoryPolicy getPolicy(ArtifactRepository repository);

    private Language language;

    private String moduleName;

    @Override
    public ProjectScope scope() {
        return (scope != null) ? scope : SourceRoot.super.scope();
    }

    @Override
    public Language language() {
        return (language != null) ? language : SourceRoot.super.language();
    }

    @Override
    public Optional<String> module() {
        return Optional.ofNullable(moduleName);

        if (event.getMetadata().getFile() != null) {
            metadata = event.getMetadata().getFile();
        } else {
            metadata = event.getMetadata();
        }

        String errorType = " is invalid";
        if (exception instanceof FileNotFoundException) {
            errorType = " is inaccessible";
        }

        String msg = "";
        if (exception != null) {

    }

    @Test
    void testOneProblem() {
        ProblemCollector problemCollector = ProblemCollectorFactory.newInstance(null);
        problemCollector.add(Problem.Severity.ERROR, "MESSAGE", 3, 5, new Exception());
        ToolchainsBuildingException e = new ToolchainsBuildingException(problemCollector.getProblems());
        assertEquals(

         *
         * @return The key-value pairs, never {@code null}.
         */
        Map<String, Object> getData();
    }

    /**
     * Initializes the spy.
     *
     * @param context The event spy context, never {@code null}.
     */
    void init(Context context) throws Exception;

    /**
     * Notifies the spy of some build event/operation.

     *
     * @param obj The object to create a string representation for, may be <code>null</code>.
     * @return The string representation, never <code>null</code>.
     */
    private String toString(Object obj) {
        String str;
        if (obj != null && obj.getClass().isArray()) {
            int n = Array.getLength(obj);
            StringBuilder buf = new StringBuilder(256);

            throws IntrospectionException {
        if (value == null || key == null) {
            return null;
        }

        if (value instanceof Map map) {
            return map.get(key);
        }

        final String message = String.format(
                "The token '%s' at position '%d' refers to a java.util.Map, but the value "