if (annotation instanceof final PDAnnotationFileAttachment annotationFileAttachment) {
                        final PDFileSpecification fileSpec = annotationFileAttachment.getFile();
                        if (fileSpec instanceof final PDComplexFileSpecification complexFileSpec) {
                            final PDEmbeddedFile embeddedFile = getEmbeddedFile(complexFileSpec);

        } else if (vf instanceof ChecksumVerificationFailure) {
            ChecksumVerificationFailure cvf = (ChecksumVerificationFailure) vf;
            String reason = "Expected a " + cvf.getKind() + " checksum of " + expected(cvf.getExpected()) + " but was " + actual(cvf.getActual());
            reportItem(reason, "checksum-mismatch", "warning");
        } else if (vf instanceof OnlyIgnoredKeys) {

        ServiceRegistry daemonServices = daemonProcessState.getServices();
        File daemonLog = daemonServices.get(DaemonLogFile.class).getFile();

        // Any logging prior to this point will not end up in the daemon log file.
        initialiseLogging(loggingManager, daemonLog);

        // Detach the process from the parent terminal/console

			CompilationResults := f.(*filter).compilationResults
			require.Equal(t, len(validations), len(CompilationResults))

			versionedAttr, err := admission.NewVersionedAttributes(tc.attributes, tc.attributes.GetKind(), newObjectInterfacesForTest())
			if err != nil {
				t.Fatalf("unexpected error on conversion: %v", err)
			}

			optionalVars := OptionalVariableBindings{VersionedParams: tc.params, Authorizer: tc.authorizer}

            } catch (Exception e) {
                artifacts.addArtifact(new DefaultUnresolvedArtifactResult(artifactMetaData.getId(), type, e));
            }
        }
    }

        def artifact = Stub(ModuleComponentArtifactMetadata) {
            getId() >> artifactId
        }

        def file = new File("local")
        def result = Stub(BuildableArtifactFileResolveResult) {
            getFile() >> file
            getFailure() >> null
        }

        def descriptorHash = Hashing.sha1().hashString("Hello")
        def moduleSource = Stub(ModuleDescriptorHashModuleSource) {

                                    return DefaultIvyArtifactName.forFile(file, null);
                                }

                                @Override
                                public File getFile() {
                                    return file;
                                }

                                @Override
                                public CalculatedValue<File> getFileSource() {

        for (ModuleLibrary moduleLibrary : Iterables.filter(dependencies, ModuleLibrary.class)) {
            for (FilePath filePath : Iterables.filter(moduleLibrary.getClasses(), FilePath.class)) {
                files.add(filePath.getFile());
            }
        }
        return files;
    }

    @SuppressWarnings({"deprecation", "unused"})

    }

    private static FileTreeElement element(boolean isFile, String... elements) {
        [
            getRelativePath: { return new RelativePath(isFile, elements) },
            getFile        : { return new File(elements.join('/')) }
        ] as FileTreeElement
    }

    private static FileTreeElement file(String... elements) {
        element(true, elements)
    }

            @Override
            public void execute(InternalProblemSpec builder) {
                InternalProblemSpec problemSpec = builder
                    // usage.getKind() could be be part of the problem ID, however it provides hints on the problem provenance which should be modeled differently, maybe as location data.