logFile = File("/tmp/key.log"), tlsVersions = tlsVersions, launch = launch)`
 * 3. Register with `client.eventListenerFactory(eventListenerFactory)`
 * 4. Launch wireshark if not done externally `val process = eventListenerFactory.launchWireShark()`
 */
@SuppressSignatureCheck
class WireSharkListenerFactory(
  private val logFile: File,
  private val tlsVersions: List<TlsVersion>,

    /**
     * Get the model based on the path when resolving the parent based on relativePath.
     *
     * @param from    the requiring model
     * @param pomFile the path to the pomFile
     * @return the model, otherwise {@code null}
     */
    Model getRawModel(Path from, Path pomFile);

    /**
     * Get the model from the reactor based on the groupId and artifactId when resolving reactor dependencies.
     *

            <inherited>true</inherited>
            <phase>validate</phase>
            <goals>
              <goal>log-string</goal>
            </goals>
            <configuration>
              <logFile>target/executions.txt</logFile>
              <string>inherited-execution</string>
            </configuration>
          </execution>
          <execution>
            <id>non-inherited-execution</id>

                                            <c:forEach var="logFile" varStatus="s"
                                                       items="${logFileItems}">
                                                <tr
                                                        data-href="${contextPath}/admin/log/download/${f:u(logFile.id)}/">
                                                    <td>${f:h(logFile.name)}</td>

            String adocFileName = adocFile.getName();
            // getting_started.adoc -> getting_started-docinfo.html
            String docInfoName = adocFileName.substring(0, adocFileName.lastIndexOf('.')) + "-docinfo.html";
            String relativePath = adocDir.relativize(adocFile.toPath()).toString();

        }
    }
}

@OptIn(KtAnalysisNonPublicApi::class)
fun List<KtFile>.collectReachableInlineDelegatedPropertyAccessors(): List<KtFile> {
    if (isEmpty()) return this

    val allFiles = mutableSetOf<KtFile>()
    allFiles.addAll(this)
    allFiles.collectReachableInlineDelegatedPropertyAccessors()
    return allFiles.toList()
}

import org.jetbrains.kotlin.config.CompilerConfiguration
import org.jetbrains.kotlin.config.JVMConfigurationKeys
import org.jetbrains.kotlin.psi.KtFile
import org.jetbrains.kotlin.utils.PathUtil
import java.io.File


class KotlinSourceParser {

    data class ParsedKotlinFiles(

        val ktFiles: List<KtFile>,

        private
        val disposable: Disposable

    ) : AutoCloseable {

        override fun close() {

	configDump, err := io.ReadAll(configDumpFile)
	if err != nil {
		t.Errorf("error reading test data file: %v", err)
	}

	outFile, err := os.Open("testdata/secret/output")
	if err != nil {
		t.Errorf("error opening test data output file: %v", err)
	}
	defer outFile.Close()
	expectedOut, err := io.ReadAll(outFile)
	if err != nil {
		t.Errorf("error reading test data output file: %v", err)
	}

	gotOut := &bytes.Buffer{}

        cos.write(new byte[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0 });
        assertFalse(cos.done);
        assertFalse(cos.isInMemory());
        File file = cos.getFile();
        assertTrue(cos.done);
        assertTrue(file.exists());
        cos.close();
        assertTrue(cos.done);
        assertTrue(file.exists());
    }

    @Test

                dependencyResolver,
                rootLocator);
    }

    @Override
    public ProjectBuildingResult build(File pomFile, ProjectBuildingRequest configuration)
            throws ProjectBuildingException {
        ProjectBuildingResult result = super.build(pomFile, configuration);

        result.getProject().setRemoteArtifactRepositories(Collections.<ArtifactRepository>emptyList());

        return result;