<type>file</type>
							<src>${project.build.directory}/generated-packaging/deb/env/fess</src>
							<dst>/etc/default/fess</dst>
							<mapper>
								<type>perm</type>
								<user>root</user>
								<group>root</group>
							</mapper>
						</data>
						<!-- Add init.d files -->
						<data>
							<type>file</type>
							<src>${project.build.directory}/generated-packaging/deb/init.d/fess</src>

    @Test
    void testThrowableConstructor() {
        // Test the constructor with a cause
        Throwable cause = new RuntimeException("Root cause of timeout");
        ConnectionTimeoutException exception = new ConnectionTimeoutException(cause);
        assertEquals("java.lang.RuntimeException: Root cause of timeout", exception.getMessage(),
                "Message should be derived from the cause");

            check(project.path == ":") {
                // We rely on the fact that root is configured first
                "BuildEnvironmentService should be registered by the root"
            }
            parameters.rootProjectDir = this@with
            parameters.rootProjectBuildDir = project.layout.buildDirectory
        }

        }

        private static void walkJavaFiles(Path root, String suffix, Consumer<Path> classConsumer) throws IOException {
            if (Files.exists(root) == false) {
                return;
            }
            Files.walk(root)
                .filter(p -> p.toString().endsWith(suffix))
                .map(root::relativize)

  config.vm.synced_folder "#{Dir.home}/.vagrant/gradle/caches/jars-3", "/root/.gradle/caches/jars-3",
      create: true,
      owner: "vagrant"
  config.vm.synced_folder "#{Dir.home}/.vagrant/gradle/caches/modules-2", "/root/.gradle/caches/modules-2",
      create: true,
      owner: "vagrant"
  config.vm.synced_folder "#{Dir.home}/.gradle/wrapper", "/root/.gradle/wrapper",
      create: true,
      owner: "vagrant"

    @Test
    void testCauseConstructor() {
        // Test the constructor with a cause argument
        Throwable cause = new RuntimeException("Root cause");
        RequestTimeoutException exception = new RequestTimeoutException(cause);
        assertEquals("java.lang.RuntimeException: Root cause", exception.getMessage(), "Message should be derived from the cause");

import java.security.cert.X509Certificate
import java.util.ArrayDeque
import java.util.Deque
import javax.net.ssl.SSLPeerUnverifiedException

/**
 * A certificate chain cleaner that uses a set of trusted root certificates to build the trusted
 * chain. This class duplicates the clean chain building performed during the TLS handshake. We
 * prefer other mechanisms where they exist, such as with

        @Override
        public void apply(Project project) {
            if (project != project.getRootProject()) {
                throw new IllegalArgumentException("VagrantSetupCheckerPlugin can only be applied to the root project of a build");
            }

            project.getGradle().getTaskGraph().whenReady(graph -> {
                boolean needsVagrant = graph.getAllTasks().stream().anyMatch(t -> t instanceof VagrantShellTask);

        // Scenario: DFS is disabled.
        when(mockConfig.isDfsDisabled()).thenReturn(true);
        assertNull(dfsImpl.resolve(mockContext, "domain", "root", "/path"));
    }

    @Test
    void testResolve_NullRoot() throws SmbAuthException {
        // Scenario: The root is null.
        assertNull(dfsImpl.resolve(mockContext, "domain", null, "/path"));
    }

    @Test

    void testConstructorWithMessageAndCause() {
        // Given
        String message = "CIFS operation failed";
        Throwable cause = new RuntimeException("Root cause");

        // When
        RuntimeCIFSException exception = new RuntimeCIFSException(message, cause);

        // Then
        assertNotNull(exception);
        assertEquals(message, exception.getMessage());