/*

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

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

 *

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

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

 * published by the Free Software Foundation.  Oracle designates this

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

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

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

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

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

 * questions.

 */

package jdk.jpackage.internal;

import java.nio.file.Path;

import java.util.Collections;

import java.util.List;

import java.util.Map;

import static org.hamcrest.CoreMatchers.equalTo;

import static org.hamcrest.CoreMatchers.not;

import static org.junit.Assert.*;

import org.junit.Test;

public class PathGroupTest {

    public PathGroupTest() {

    }

    @Test(expected = NullPointerException.class)

    public void testNullId() {

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

    }

    @Test

    public void testEmptyPathGroup() {

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

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

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

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

    }

    @Test

    public void testRootsSinglePath() {

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

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

        assertEquals(1, paths.size());

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

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

        assertEquals(1, roots.size());

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

    }

    @Test

    public void testDuplicatedRoots() {

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

                PATH_FOO, "root", PATH_EMPTY));

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

        Collections.sort(paths);

        assertEquals(3, paths.size());

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

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

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

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

        assertEquals(1, roots.size());

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

    }

    @Test

    public void testRoots() {

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

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

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

        assertEquals(3, paths.size());

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

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

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

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

        assertEquals(1, roots.size());

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

    }

    @Test

    public void testResolveAt() {

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

                PATH_EMPTY));

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

        final PathGroup pg2 = pg.resolveAt(aPath);

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

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

        assertEquals(3, paths.size());

        assertTrue(paths.contains(PATH_EMPTY));

        assertTrue(paths.contains(PATH_FOO));

        assertTrue(paths.contains(PATH_BAR));

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

        paths = pg2.paths();

        assertEquals(3, paths.size());

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

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

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

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

    }

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

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

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

}