PathTest.java

/*******************************************************************************
 * Copyright (c) 2012-2017 Codenvy, S.A.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *   Codenvy, S.A. - initial API and implementation
 *******************************************************************************/
package org.eclipse.che.ide.resource;

import org.junit.Test;

import java.util.Arrays;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNotSame;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertTrue;

/**
 * Tests for the {@link Path}.
 *
 * @author Vlad Zhukovskyi
 * @see Path
 */
public class PathTest {

    @Test
    public void testShouldReturnNewPathBasedOnValue() throws Exception {
        final String sPath = "/path/segment";
        final Path path = Path.valueOf(sPath);

        assertEquals(path.toString(), "/path/segment");
    }

    @Test
    public void testShouldReturnNewPathWithCallingConstructor() throws Exception {
        final String sPath = "/path/segment";
        final Path path = new Path(sPath);

        assertEquals(path.toString(), "/path/segment");
    }

    @Test
    public void testShouldReturnNewPathWithDeviceId() throws Exception {
        final String sPath = "/path/segment";
        final String sDevice = "/mnt";
        final Path path = new Path(sDevice, sPath);

        assertEquals(path.toString(), "/mnt/path/segment");
    }

    @Test
    public void testShouldReturnNewPathAfterAddingExtension() throws Exception {
        final Path path = Path.valueOf("/foo");
        final Path file = path.addFileExtension("ext");

        assertNotSame(path, file);
        assertTrue(path.toString().equals("/foo"));
        assertTrue(file.toString().equals("/foo.ext"));
    }

    @Test
    public void testShouldReturnNewPathAfterOperationWithTrailingSeparatorToPath() throws Exception {
        final Path path = Path.valueOf("/foo");

        assertFalse(path.hasTrailingSeparator());

        final Path pathWithSeparator = path.addTrailingSeparator();

        assertNotSame(path, pathWithSeparator);
        assertFalse(path.hasTrailingSeparator());
        assertTrue(pathWithSeparator.hasTrailingSeparator());
        assertTrue(path.toString().equals("/foo"));
        assertTrue(pathWithSeparator.hasTrailingSeparator());
        assertTrue(pathWithSeparator.toString().equals("/foo/"));

        final Path pathWithRemovedSeparator = pathWithSeparator.removeTrailingSeparator();

        assertTrue(path.equals(pathWithRemovedSeparator));
        assertFalse(pathWithRemovedSeparator.hasTrailingSeparator());
    }

    @Test
    public void testShouldReturnNewPathAfterAppendingAnotherPath() throws Exception {
        final Path path = Path.valueOf("/foo");
        final Path tmpPath = Path.valueOf("/tmp");

        final Path appended = path.append(tmpPath);

        assertNotSame(path, appended);
        assertTrue(path.toString().equals("/foo"));
        assertTrue(tmpPath.toString().equals("/tmp"));
        assertTrue(appended.toString().equals("/foo/tmp"));
    }

    @Test
    public void testShouldReturnNewPathAfterAppendingAnotherStringPath() throws Exception {
        final Path path = Path.valueOf("/foo");

        final Path appended = path.append("/tmp");

        assertNotSame(path, appended);
        assertTrue(path.toString().equals("/foo"));
        assertTrue(appended.toString().equals("/foo/tmp"));
    }

    @Test
    public void testShouldCheckPathEquality() throws Exception {
        assertTrue(Path.valueOf("/foo").equals(Path.valueOf("/foo")));
        assertTrue(Path.valueOf("/foo").equals(Path.valueOf("/foo/")));
        assertTrue(new Path("/mnt", "/foo").equals(new Path("/mnt", "/foo")));
        assertFalse(Path.valueOf("/foo").equals(Path.valueOf("/foo/a/b")));
        assertFalse(new Path("/mnt", "/foo").equals(new Path("/mount", "/foo")));
        assertFalse(Path.valueOf("/foo").equals(Path.valueOf("foo/")));
    }

    @Test
    public void testShouldCheckDeviceId() throws Exception {
        final Path path = new Path("/mnt", "/foo");

        assertTrue(path.getDevice().equals("/mnt"));
    }

    @Test
    public void testShouldCheckFileExtension() throws Exception {
        final Path path = Path.valueOf("/foo");

        assertNull(path.getFileExtension());

        final Path extPath = path.addFileExtension("ext");

        assertNotSame(path, extPath);
        assertNull(path.getFileExtension());
        assertNotNull(extPath.getFileExtension());
        assertTrue(extPath.getFileExtension().equals("ext"));
        assertTrue(extPath.toString().equals("/foo.ext"));

        final Path removedExtPath = extPath.removeFileExtension();

        assertNotSame(path, removedExtPath);
        assertNotSame(extPath, removedExtPath);
        assertTrue(path.equals(removedExtPath));
        assertTrue(removedExtPath.toString().equals("/foo"));
    }

    @Test
    public void testShouldReturnTrueWhenTwoEqualPathHaveSameHashCode() throws Exception {
        assertTrue(Path.valueOf("/foo").hashCode() == Path.valueOf("/foo").hashCode());
        assertTrue(Path.valueOf("/foo").hashCode() == Path.valueOf("/foo/").hashCode());
    }

    @Test
    public void testShouldCheckExistenceOfTrailingSeparator() throws Exception {
        assertTrue(Path.valueOf("/foo/").hasTrailingSeparator());
        assertFalse(Path.valueOf("/foo").hasTrailingSeparator());
        assertFalse(Path.valueOf("/").hasTrailingSeparator());
        assertFalse(Path.valueOf("").hasTrailingSeparator());
    }

    @Test
    public void testShouldCheckAbsolutePath() throws Exception {
        assertTrue(Path.valueOf("/foo").isAbsolute());
        assertFalse(Path.valueOf("foo").isAbsolute());
    }

    @Test
    public void testShouldCheckEmptiness() throws Exception {
        assertTrue(Path.valueOf("").isEmpty());
        assertFalse(Path.valueOf("/").isEmpty());
    }

    @Test
    public void testShouldCheckPathPrefix() throws Exception {
        assertTrue(Path.valueOf("").isPrefixOf(Path.valueOf("")));
        assertTrue(Path.valueOf("/").isPrefixOf(Path.valueOf("")));
        assertTrue(Path.valueOf("").isPrefixOf(Path.valueOf("/")));
        assertTrue(Path.valueOf("/").isPrefixOf(Path.valueOf("/")));
        assertTrue(Path.valueOf("/").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertTrue(Path.valueOf("/foo").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertTrue(Path.valueOf("/foo/").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertTrue(Path.valueOf("foo").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertTrue(Path.valueOf("/foo/a/b/c").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertFalse(Path.valueOf("/foo/a/b/c/d").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertFalse(Path.valueOf("/foo/a/x/c").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertFalse(Path.valueOf("foo/a/x/c").isPrefixOf(Path.valueOf("/foo/a/b/c")));
        assertFalse(Path.valueOf("abc").isPrefixOf(Path.valueOf("def")));
    }

    @Test
    public void testShouldCheckIsPathRoot() throws Exception {
        assertTrue(Path.valueOf("/").isRoot());
        assertFalse(Path.valueOf("/foo").isRoot());
        assertFalse(Path.valueOf("").isRoot());
        assertFalse(Path.valueOf("foo").isRoot());
    }

    @Test
    public void testShouldCheckIfPathIsUnc() throws Exception {
        final Path path = Path.valueOf("//foo");

        assertNull(path.getDevice());
        assertTrue(path.isUNC());
        assertFalse(Path.valueOf("/foo").isUNC());
    }

    @Test
    public void testShouldCheckPathValidity() throws Exception {
        assertTrue(Path.isValidPath("/"));
        assertTrue(Path.isValidPath("/foo/bar"));

        assertFalse(Path.isValidSegment(""));
        assertFalse(Path.isValidSegment("foo/bar"));
    }

    @Test
    public void testShouldCheckLastSegmentOperations() throws Exception {
        final Path path = Path.valueOf("/foo/a/b/c/bar");

        assertTrue(path.lastSegment().equals("bar"));
        assertTrue(path.segmentCount() == 5);
        assertTrue(Arrays.equals(path.segments(), new String[]{"foo", "a", "b", "c", "bar"}));
        assertEquals(path.segment(0), "foo");
        assertEquals(path.segment(1), "a");
        assertEquals(path.segment(2), "b");
        assertEquals(path.segment(3), "c");
        assertEquals(path.segment(4), "bar");
        assertTrue(path.matchingFirstSegments(Path.valueOf("/foo/a/b/c/bar")) == 5);
        assertTrue(path.matchingFirstSegments(Path.valueOf("/foo/a/x/x/x")) == 2);
        assertTrue(path.matchingFirstSegments(Path.valueOf("/x/x/x/x/x")) == 0);
        assertTrue(path.removeFirstSegments(1).equals(Path.valueOf("a/b/c/bar")));
        assertTrue(path.removeLastSegments(1).equals(Path.valueOf("/foo/a/b/c")));
        assertTrue(path.uptoSegment(1).equals(Path.valueOf("/foo")));
        assertTrue(path.uptoSegment(2).equals(Path.valueOf("/foo/a")));
        assertTrue(path.uptoSegment(3).equals(Path.valueOf("/foo/a/b")));
        assertTrue(path.uptoSegment(4).equals(Path.valueOf("/foo/a/b/c")));
    }

    @Test
    public void testShouldSetCorrectDevice() throws Exception {
        final Path path = Path.valueOf("/foo");

        assertNull(path.getDevice());

        final Path pathWithDevice = path.setDevice("mnt:");

        assertNotSame(path, pathWithDevice);
        assertFalse(path.equals(pathWithDevice));
        assertTrue(pathWithDevice.toString().equals("mnt:/foo"));
    }

    @Test
    public void testShouldReturnCommonPath() throws Exception {
        final Path common = Path.valueOf("/foo");

        final Path path1 = common.append("a/b");
        final Path path2 = common.append("a/c");
        final Path path3 = common.append("a/d");
        final Path path4 = common.append("c/d/b");
        final Path path5 = common.append("a/d/c");
        final Path path6 = common.append("a/c/c");

        final Path result = Path.commonPath(path1, path2, path3, path4, path5, path6);

        assertEquals(result, common);
    }

    @Test
    public void testShouldReturnRootPathAsCommon() throws Exception {
        final Path path1 = Path.valueOf("/a");
        final Path path2 = Path.valueOf("/b");
        final Path path3 = Path.valueOf("/c");
        final Path path4 = Path.valueOf("/d");
        final Path path5 = Path.valueOf("/e");

        final Path result = Path.commonPath(path1, path2, path3, path4, path5);

        assertEquals(result, Path.ROOT);
    }

    @Test
    public void testShouldReturnRootPathAsCommon2() throws Exception {
        final Path path1 = Path.valueOf("/a");
        final Path path2 = Path.valueOf("b");
        final Path path3 = Path.valueOf("/c");
        final Path path4 = Path.valueOf("d");
        final Path path5 = Path.valueOf("/e");

        final Path result = Path.commonPath(path1, path2, path3, path4, path5);

        assertEquals(result, Path.ROOT);
    }

    @Test
    public void testShouldReturnEmptyPathForEmptyInputArray() throws Exception {
        final Path result = Path.commonPath();

        assertEquals(result, Path.EMPTY);
    }

    @Test(expected = NullPointerException.class)
    public void testShouldThrowNPEOnNullArgument() throws Exception {
        Path.commonPath(null);
    }

    @Test
    public void testShouldReturnSamePathAsOneGivenAsArgument() throws Exception {
        final Path path = Path.valueOf("/some/path");

        final Path result = Path.commonPath(path);

        assertEquals(result, path);
    }

    @Test
    public void testShouldReturnCorrectCommonPathIfPathHasSegmentsMoreThanPathCount() throws Exception {
        final Path common = Path.valueOf("/foo");

        final Path path1 = common.append("a/b/c/d/e/f/g/h/i/j/k/l");
        final Path path2 = common.append("b/c");

        final Path result = Path.commonPath(path1, path2);

        assertEquals(result, common);
    }
}