1 /*

     2  * Copyright (c) 2019, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.  Oracle designates this

     8  * particular file as subject to the "Classpath" exception as provided

     9  * by Oracle in the LICENSE file that accompanied this code.

    10  *

    11  * This code is distributed in the hope that it will be useful, but WITHOUT

    12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    14  * version 2 for more details (a copy is included in the LICENSE file that

    15  * accompanied this code).

    16  *

    17  * You should have received a copy of the GNU General Public License version

    18  * 2 along with this work; if not, write to the Free Software Foundation,

    19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    20  *

    21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

    22  * or visit www.oracle.com if you need additional information or have any

    23  * questions.

    24  */

    25 package jdk.incubator.jpackage.internal;

    26 

    27 import java.io.IOException;

    28 import java.nio.file.Files;

    29 import java.nio.file.Path;

    30 import java.util.*;

    31 import java.util.function.Consumer;

    32 import java.util.function.Predicate;

    33 import java.util.function.UnaryOperator;

    34 import java.util.stream.Collectors;

    35 import java.util.stream.Stream;

    36 import static org.hamcrest.CoreMatchers.equalTo;

    37 import static org.hamcrest.CoreMatchers.not;

    38 import static org.junit.Assert.*;

    39 import org.junit.Rule;

    40 import org.junit.Test;

    41 import org.junit.rules.TemporaryFolder;

    42 

    43 

    44 public class PathGroupTest {

    45 

    46     @Rule

    47     public final TemporaryFolder tempFolder = new TemporaryFolder();

    48 

    49     @Test(expected = NullPointerException.class)

    50     public void testNullId() {

    51          new PathGroup(Map.of()).getPath(null);

    52     }

    53 

    54     @Test

    55     public void testEmptyPathGroup() {

    56         PathGroup pg = new PathGroup(Map.of());

    57 

    58         assertNull(pg.getPath("foo"));

    59 

    60         assertEquals(0, pg.paths().size());

    61         assertEquals(0, pg.roots().size());

    62     }

    63 

    64     @Test

    65     public void testRootsSinglePath() {

    66         final PathGroup pg = new PathGroup(Map.of("main", PATH_FOO));

    67 

    68         List<Path> paths = pg.paths();

    69         assertEquals(1, paths.size());

    70         assertEquals(PATH_FOO, paths.iterator().next());

    71 

    72         List<Path> roots = pg.roots();

    73         assertEquals(1, roots.size());

    74         assertEquals(PATH_FOO, roots.iterator().next());

    75     }

    76 

    77     @Test

    78     public void testDuplicatedRoots() {

    79         final PathGroup pg = new PathGroup(Map.of("main", PATH_FOO, "another",

    80                 PATH_FOO, "root", PATH_EMPTY));

    81 

    82         List<Path> paths = pg.paths();

    83         Collections.sort(paths);

    84 

    85         assertEquals(3, paths.size());

    86         assertEquals(PATH_EMPTY, paths.get(0));

    87         assertEquals(PATH_FOO, paths.get(1));

    88         assertEquals(PATH_FOO, paths.get(2));

    89 

    90         List<Path> roots = pg.roots();

    91         assertEquals(1, roots.size());

    92         assertEquals(PATH_EMPTY, roots.get(0));

    93     }

    94 

    95     @Test

    96     public void testRoots() {

    97         final PathGroup pg = new PathGroup(Map.of(1, Path.of("foo"), 2, Path.of(

    98                 "foo", "bar"), 3, Path.of("foo", "bar", "buz")));

    99 

   100         List<Path> paths = pg.paths();

   101         assertEquals(3, paths.size());

   102         assertTrue(paths.contains(Path.of("foo")));

   103         assertTrue(paths.contains(Path.of("foo", "bar")));

   104         assertTrue(paths.contains(Path.of("foo", "bar", "buz")));

   105 

   106         List<Path> roots = pg.roots();

   107         assertEquals(1, roots.size());

   108         assertEquals(Path.of("foo"), roots.get(0));

   109     }

   110 

   111     @Test

   112     public void testResolveAt() {

   113         final PathGroup pg = new PathGroup(Map.of(0, PATH_FOO, 1, PATH_BAR, 2,

   114                 PATH_EMPTY));

   115 

   116         final Path aPath = Path.of("a");

   117 

   118         final PathGroup pg2 = pg.resolveAt(aPath);

   119         assertThat(pg, not(equalTo(pg2)));

   120 

   121         List<Path> paths = pg.paths();

   122         assertEquals(3, paths.size());

   123         assertTrue(paths.contains(PATH_EMPTY));

   124         assertTrue(paths.contains(PATH_FOO));

   125         assertTrue(paths.contains(PATH_BAR));

   126         assertEquals(PATH_EMPTY, pg.roots().get(0));

   127 

   128         paths = pg2.paths();

   129         assertEquals(3, paths.size());

   130         assertTrue(paths.contains(aPath.resolve(PATH_EMPTY)));

   131         assertTrue(paths.contains(aPath.resolve(PATH_FOO)));

   132         assertTrue(paths.contains(aPath.resolve(PATH_BAR)));

   133         assertEquals(aPath, pg2.roots().get(0));

   134     }

   135 

   136     @Test

   137     public void testTransform() throws IOException {

   138         for (var transform : TransformType.values()) {

   139             testTransform(false, transform);

   140         }

   141     }

   142 

   143     @Test

   144     public void testTransformWithExcludes() throws IOException {

   145         for (var transform : TransformType.values()) {

   146             testTransform(true, transform);

   147         }

   148     }

   149 

   150     enum TransformType { Copy, Move, Handler };

   151 

   152     private void testTransform(boolean withExcludes, TransformType transform)

   153             throws IOException {

   154         final PathGroup pg = new PathGroup(Map.of(0, PATH_FOO, 1, PATH_BAR, 2,

   155                 PATH_EMPTY, 3, PATH_BAZ));

   156 

   157         final Path srcDir = tempFolder.newFolder().toPath();

   158         final Path dstDir = tempFolder.newFolder().toPath();

   159 

   160         Files.createDirectories(srcDir.resolve(PATH_FOO).resolve("a/b/c/d"));

   161         Files.createFile(srcDir.resolve(PATH_FOO).resolve("a/b/c/file1"));

   162         Files.createFile(srcDir.resolve(PATH_FOO).resolve("a/b/file2"));

   163         Files.createFile(srcDir.resolve(PATH_FOO).resolve("a/b/file3"));

   164         Files.createFile(srcDir.resolve(PATH_BAR));

   165         Files.createFile(srcDir.resolve(PATH_EMPTY).resolve("file4"));

   166         Files.createDirectories(srcDir.resolve(PATH_BAZ).resolve("1/2/3"));

   167 

   168         var dst = pg.resolveAt(dstDir);

   169         var src = pg.resolveAt(srcDir);

   170         if (withExcludes) {

   171             // Exclude from transformation.

   172             src.setPath(new Object(), srcDir.resolve(PATH_FOO).resolve("a/b/c"));

   173             src.setPath(new Object(), srcDir.resolve(PATH_EMPTY).resolve("file4"));

   174         }

   175 

   176         var srcFilesBeforeTransform = walkFiles(srcDir);

   177 

   178         if (transform == TransformType.Handler) {

   179             List<Map.Entry<Path, Path>> copyFile = new ArrayList<>();

   180             List<Path> createDirectory = new ArrayList<>();

   181             src.transform(dst, new PathGroup.TransformHandler() {

   182                 @Override

   183                 public void copyFile(Path src, Path dst) throws IOException {

   184                     copyFile.add(Map.entry(src, dst));

   185                 }

   186 

   187                 @Override

   188                 public void createDirectory(Path dir) throws IOException {

   189                     createDirectory.add(dir);

   190                 }

   191             });

   192 

   193             Consumer<Path> assertFile = path -> {

   194                 var entry = Map.entry(srcDir.resolve(path), dstDir.resolve(path));

   195                 assertTrue(copyFile.contains(entry));

   196             };

   197 

   198             Consumer<Path> assertDir = path -> {

   199                 assertTrue(createDirectory.contains(dstDir.resolve(path)));

   200             };

   201 

   202             assertEquals(withExcludes ? 3 : 5, copyFile.size());

   203             assertEquals(withExcludes ? 8 : 10, createDirectory.size());

   204 

   205             assertFile.accept(PATH_FOO.resolve("a/b/file2"));

   206             assertFile.accept(PATH_FOO.resolve("a/b/file3"));

   207             assertFile.accept(PATH_BAR);

   208             assertDir.accept(PATH_FOO.resolve("a/b"));

   209             assertDir.accept(PATH_FOO.resolve("a"));

   210             assertDir.accept(PATH_FOO);

   211             assertDir.accept(PATH_BAZ);

   212             assertDir.accept(PATH_BAZ.resolve("1"));

   213             assertDir.accept(PATH_BAZ.resolve("1/2"));

   214             assertDir.accept(PATH_BAZ.resolve("1/2/3"));

   215             assertDir.accept(PATH_EMPTY);

   216 

   217             if (!withExcludes) {

   218                 assertFile.accept(PATH_FOO.resolve("a/b/c/file1"));

   219                 assertFile.accept(PATH_EMPTY.resolve("file4"));

   220                 assertDir.accept(PATH_FOO.resolve("a/b/c/d"));

   221                 assertDir.accept(PATH_FOO.resolve("a/b/c"));

   222             }

   223 

   224             assertArrayEquals(new Path[] { Path.of("") }, walkFiles(dstDir));

   225             return;

   226         }

   227 

   228         if (transform == TransformType.Copy) {

   229             src.copy(dst);

   230         } else if (transform == TransformType.Move) {

   231             src.move(dst);

   232         }

   233 

   234         final List<Path> excludedPaths;

   235         if (withExcludes) {

   236             excludedPaths = List.of(

   237                 PATH_EMPTY.resolve("file4"),

   238                 PATH_FOO.resolve("a/b/c")

   239             );

   240         } else {

   241             excludedPaths = Collections.emptyList();

   242         }

   243         UnaryOperator<Path[]> removeExcludes = paths -> {

   244             return Stream.of(paths)

   245                     .filter(path -> !excludedPaths.stream().anyMatch(

   246                             path::startsWith))

   247                     .collect(Collectors.toList()).toArray(Path[]::new);

   248         };

   249 

   250         var dstFiles = walkFiles(dstDir);

   251         assertArrayEquals(removeExcludes.apply(srcFilesBeforeTransform), dstFiles);

   252 

   253         if (transform == TransformType.Copy) {

   254             assertArrayEquals(dstFiles, removeExcludes.apply(walkFiles(srcDir)));

   255         } else if (transform == TransformType.Move) {

   256             assertFalse(Files.exists(srcDir));

   257         }

   258     }

   259 

   260     private static Path[] walkFiles(Path root) throws IOException {

   261         try (var files = Files.walk(root)) {

   262             return files.map(root::relativize).sorted().collect(

   263                     Collectors.toList()).toArray(Path[]::new);

   264         }

   265     }

   266 

   267     private final static Path PATH_FOO = Path.of("foo");

   268     private final static Path PATH_BAR = Path.of("bar");

   269     private final static Path PATH_BAZ = Path.of("baz");

   270     private final static Path PATH_EMPTY = Path.of("");

   271 }