MapPathTest.java

Go to the documentation of this file.

/*
 * Gridarta MMORPG map editor for Crossfire, Daimonin and similar games.
 * Copyright (C) 2000-2023 The Gridarta Developers.
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
package net.sf.gridarta.model.mapmodel;
 
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;
import org.junit.Test;
 
public class MapPathTest {
 
    @Test
    public void testAbsolute1() {
        final AbsoluteMapPath p1 = check("/", new AbsoluteMapPath());
        final AbsoluteMapPath p2 = check("/x", new AbsoluteMapPath(p1, "x"));
        final AbsoluteMapPath p3 = check("/x/y", new AbsoluteMapPath(p2, "y"));
        final AbsoluteMapPath p4 = check("/x/y/z", new AbsoluteMapPath(p3, "z"));
        final AbsoluteMapPath p5 = check("/x/y", new AbsoluteMapPath(p4, ".."));
        final AbsoluteMapPath p6 = check("/x/y", new AbsoluteMapPath(p5, "."));
        final AbsoluteMapPath p7 = check("/x", new AbsoluteMapPath(p6, ".."));
        final AbsoluteMapPath p8 = check("/", new AbsoluteMapPath(p7, ".."));
        check("/", new AbsoluteMapPath(p8, ".."));
    }
 
    @Test
    public void testRelative1() {
        final RelativeMapPath p1 = check("", new RelativeMapPath());
        final RelativeMapPath p2 = check("x", new RelativeMapPath(p1, "x"));
        final RelativeMapPath p3 = check("x/y", new RelativeMapPath(p2, "y"));
        final RelativeMapPath p4 = check("x/y/z", new RelativeMapPath(p3, "z"));
        final RelativeMapPath p5 = check("x/y", new RelativeMapPath(p4, ".."));
        final RelativeMapPath p6 = check("x/y", new RelativeMapPath(p5, "."));
        final RelativeMapPath p7 = check("x", new RelativeMapPath(p6, ".."));
        final RelativeMapPath p8 = check("", new RelativeMapPath(p7, ".."));
        final RelativeMapPath p9 = check("..", new RelativeMapPath(p8, ".."));
        final RelativeMapPath p10 = check("..", new RelativeMapPath(p9, "."));
        final RelativeMapPath p11 = check("../..", new RelativeMapPath(p10, ".."));
        final RelativeMapPath p12 = check("../../x", new RelativeMapPath(p11, "x"));
        final RelativeMapPath p13 = check("../../x", new RelativeMapPath(p12, "."));
        final RelativeMapPath p14 = check("../../x/x", new RelativeMapPath(p13, "x"));
        final RelativeMapPath p15 = check("../../x", new RelativeMapPath(p14, ".."));
        final RelativeMapPath p16 = check("../..", new RelativeMapPath(p15, ".."));
        check("../../..", new RelativeMapPath(p16, ".."));
    }
 
    @Test(expected = IllegalArgumentException.class)
    public void testInvalid1() {
        new AbsoluteMapPath(new AbsoluteMapPath(), "");
    }
 
    @Test(expected = IllegalArgumentException.class)
    public void testInvalid2() {
        new AbsoluteMapPath(new AbsoluteMapPath(), "/");
    }
 
    @Test(expected = IllegalArgumentException.class)
    public void testInvalid3() {
        new AbsoluteMapPath(new AbsoluteMapPath(), "abc/def");
    }
 
    @Test
    public void testGetRelativeMapPathTo1() {
        check("../../../x/y/a/b", MapPathUtils.newMapPath("/x/y/a/b").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a/b/c/d")));
        check("../x/y/z", MapPathUtils.newMapPath("/a/b/x/y/z").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a/b/c/d")));
        check("../../a", MapPathUtils.newMapPath("/a").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a/b/c")));
        check("a/b/c", MapPathUtils.newMapPath("/a/b/c").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a")));
        check("b/c", MapPathUtils.newMapPath("/a/b/c").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a/b")));
        check("b", MapPathUtils.newMapPath("/a/b").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a/b")));
        check("a", MapPathUtils.newMapPath("/a").getRelativeMapPathFrom(MapPathUtils.newAbsoluteMapPath("/a")));
    }
 
    @Test
    public void testGetMapComponent1() {
        Assert.assertNull(MapPathUtils.newMapPath("").getMapComponent());
        Assert.assertNull(MapPathUtils.newMapPath("a").getMapComponent());
        Assert.assertNull(MapPathUtils.newMapPath("a/b").getMapComponent());
        Assert.assertNull(MapPathUtils.newMapPath("a/b/c").getMapComponent());
        Assert.assertNull(MapPathUtils.newMapPath("../..").getMapComponent());
 
        Assert.assertNull(MapPathUtils.newMapPath("/").getMapComponent());
        Assert.assertNull(MapPathUtils.newMapPath("/a").getMapComponent());
        Assert.assertEquals("a", MapPathUtils.newMapPath("/a/b").getMapComponent());
        Assert.assertEquals("a", MapPathUtils.newMapPath("/a/b/c").getMapComponent());
        Assert.assertEquals("abc", MapPathUtils.newMapPath("/abc/def/ghi").getMapComponent());
    }
 
    @NotNull
    private static <T extends MapPath> T check(@NotNull final String expected, @NotNull final T mapPath) {
        Assert.assertEquals(expected, mapPath.toString());
        return mapPath;
    }
 
}