src/test/java/org/apache/maven/plugins/war/util/PathSetTest.java

package org.apache.maven.plugins.war.util;

/*
 * Licensed to the Apache Software Foundation (ASF) under one
 * or more contributor license agreements.  See the NOTICE file
 * distributed with this work for additional information
 * regarding copyright ownership.  The ASF licenses this file
 * to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance
 * with the License.  You may obtain a copy of the License at
 *
 *  http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
 * KIND, either express or implied.  See the License for the
 * specific language governing permissions and limitations
 * under the License.
 */

import junit.framework.TestCase;

import org.apache.maven.plugins.war.util.PathSet;
import org.codehaus.plexus.util.StringUtils;

import java.io.File;
import java.io.IOException;
import java.nio.file.Path;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

public class PathSetTest
    extends TestCase
{

    /* --------------- Normalization tests --------------*/

    /**
     * Test method for 'org.apache.maven.plugin.war.PathSet.normalizeSubPath(String)'
     */
    public void testNormalizeSubPath()
    {
        assertEquals( "Normalized path error", "", PathSet.normalizeSubPath( "" ) );
        assertEquals( "Normalized path error", "", PathSet.normalizeSubPath( "/" ) );
        assertEquals( "Normalized path error", "", PathSet.normalizeSubPath( "////" ) );
        assertEquals( "Normalized path error", "", PathSet.normalizeSubPath( "\\" ) );
        assertEquals( "Normalized path error", "", PathSet.normalizeSubPath( "\\\\\\\\" ) );

        assertEquals( "Normalized path error", "abc", PathSet.normalizeSubPath( "abc" ) );
        assertEquals( "Normalized path error", "abc", PathSet.normalizeSubPath( "/abc" ) );
        assertEquals( "Normalized path error", "abc", PathSet.normalizeSubPath( "////abc" ) );
        assertEquals( "Normalized path error", "abc", PathSet.normalizeSubPath( "\\abc" ) );
        assertEquals( "Normalized path error", "abc", PathSet.normalizeSubPath( "\\\\\\\\abc" ) );

        assertEquals( "Normalized path error", "abc/def/xyz", PathSet.normalizeSubPath( "abc/def\\xyz\\" ) );
        assertEquals( "Normalized path error", "abc/def/xyz", PathSet.normalizeSubPath( "/abc/def/xyz/" ) );
        assertEquals( "Normalized path error", "abc/def/xyz", PathSet.normalizeSubPath( "////abc/def/xyz/" ) );
        assertEquals( "Normalized path error", "abc/def/xyz", PathSet.normalizeSubPath( "\\abc/def/xyz/" ) );
        assertEquals( "Normalized path error", "abc/def/xyz",
                PathSet.normalizeSubPath( "\\\\\\\\abc/def/xyz/" ) );
        // MWAR-371
        assertEquals( "Normalized path error", "abc/def/ghi",
                PathSet.normalizeSubPath( "///abc/////def////ghi//" ) );
    }

    /* -------------- Operations tests ------------------*/

    /**
     * Test method for:
     * <ul>
     * <li>org.apache.maven.plugin.war.PathSet.PathSet()</li>
     * <li>org.apache.maven.plugin.war.PathSet.size()</li>
     * <li>org.apache.maven.plugin.war.PathSet.add()</li>
     * <li>org.apache.maven.plugin.war.PathSet.addAll()</li>
     * <li>org.apache.maven.plugin.war.PathSet.iterate()</li>
     * <li>org.apache.maven.plugin.war.PathSet.contains()</li>
     * <li>org.apache.maven.plugin.war.PathSet.addPrefix(String)</li>
     * </ul>
     */
    public void testPathsSetBasic()
    {
        PathSet ps = new PathSet();
        assertEquals( "Unexpected PathSet size", ps.size(), 0 );
        Iterator<String> iter = ps.iterator();
        assertNotNull( "Iterator is null", iter );
        assertFalse( "Can iterate on empty set", iter.hasNext() );

        ps.add( "abc" );
        assertEquals( "Unexpected PathSet size", ps.size(), 1 );
        ps.add( "abc" );
        assertEquals( "Unexpected PathSet size", ps.size(), 1 );
        ps.add( "xyz/abc" );
        assertEquals( "Unexpected PathSet size", ps.size(), 2 );
        ps.add( "///abc" );
        assertEquals( "Unexpected PathSet size", ps.size(), 2 );
        ps.add( "///xyz\\abc" );
        assertEquals( "Unexpected PathSet size", ps.size(), 2 );

        ps.addAll( ps );
        assertEquals( "Unexpected PathSet size", ps.size(), 2 );

        int i = 0;
        for (String pathstr : ps) {
            i++;
            assertTrue(ps.contains(pathstr));
            assertTrue(ps.contains("/" + pathstr));
            assertTrue(ps.contains("/" + StringUtils.replace(pathstr, '/', '\\')));
            assertFalse(ps.contains("/" + StringUtils.replace(pathstr, '/', '\\') + "/a"));
            assertFalse(ps.contains("/a/" + StringUtils.replace(pathstr, '/', '\\')));
        }
        assertEquals( "Wrong count of iterations", 2, i );

        ps.addPrefix( "/ab/c/" );
        i = 0;
        for (String pathstr : ps) {
            i++;
            assertTrue(pathstr.startsWith("ab/c/"));
            assertFalse(pathstr.startsWith("ab/c//"));
            assertTrue(ps.contains(pathstr));
            assertTrue(ps.contains("/" + pathstr));
            assertTrue(ps.contains("/" + StringUtils.replace(pathstr, '/', '\\')));
            assertFalse(ps.contains("/" + StringUtils.replace(pathstr, '/', '\\') + "/a"));
            assertFalse(ps.contains("/ab/" + StringUtils.replace(pathstr, '/', '\\')));
        }
        assertEquals( "Wrong count of iterations", 2, i );
    }

    /**
     * Test method for:
     * <ul>
     * <li>org.apache.maven.plugin.war.PathSet.PathSet(Collection)</li>
     * <li>org.apache.maven.plugin.war.PathSet.PathSet(String[])</li>
     * <li>org.apache.maven.plugin.war.PathSet.Add</li>
     * <li>org.apache.maven.plugin.war.PathSet.AddAll(String[],String)</li>
     * <li>org.apache.maven.plugin.war.PathSet.AddAll(Collection,String)</li>
     * </ul>
     */
    public void testPathsSetAddAlls()
    {
        Set<String> s1set = new HashSet<String>();
        s1set.add( "/a/b" );
        s1set.add( "a/b/c" );
        s1set.add( "a\\b/c" );
        s1set.add( "//1//2\3a" );

        String[] s2ar = new String[]{"/a/b", "a2/b2/c2", "a2\\b2/c2", "//21//22\23a"};

        PathSet ps1 = new PathSet( s1set );
        assertEquals( "Unexpected PathSet size", 3, ps1.size() );

        PathSet ps2 = new PathSet( s2ar );
        assertEquals( "Unexpected PathSet size", 3, ps2.size() );

        ps1.addAll( s2ar );
        assertEquals( "Unexpected PathSet size", 5, ps1.size() );

        ps2.addAll( s1set );
        assertEquals( "Unexpected PathSet size", 5, ps2.size() );

        for (String str : ps1) {
            assertTrue(str, ps2.contains(str));
            assertTrue(ps2.contains("/" + str));
            assertTrue(ps1.contains(str));
            assertTrue(ps1.contains("/" + str));
        }

        for (String str : ps2) {
            assertTrue(ps1.contains(str));
            assertTrue(ps1.contains("/" + str));
            assertTrue(ps2.contains(str));
            assertTrue(ps2.contains("/" + str));
        }

        ps1.addAll( s2ar, "/pref/" );
        assertEquals( "Unexpected PathSet size", 8, ps1.size() );

        ps2.addAll( s2ar, "/pref/" );
        assertEquals( "Unexpected PathSet size", 8, ps2.size() );

        for (String str : ps1) {
            assertTrue(str, ps2.contains(str));
            assertTrue(ps2.contains("/" + str));
            assertTrue(ps1.contains(str));
            assertTrue(ps1.contains("/" + str));
        }

        for (String str : ps2) {
            assertTrue(ps1.contains(str));
            assertTrue(ps1.contains("/" + str));
            assertTrue(ps2.contains(str));
            assertTrue(ps2.contains("/" + str));
        }

        PathSet ps3 = new PathSet();
        ps3.addAll(new String[]{ "a/b/c" }, "d");
        assertTrue( "Unexpected PathSet path", ps3.contains( "d/a/b/c" ) );
    }

    /**
     * Test method for 'org.apache.maven.plugin.war.PathSet.addAllFilesInDirectory(File, String)'
     *
     * @throws IOException if an io error occurred
     */
    public void testAddAllFilesInDirectory()
        throws IOException
    {
        PathSet ps = new PathSet();

        /* Preparing directory structure*/
        File testDir = new File( "target/testAddAllFilesInDirectory" );
        testDir.mkdirs();

        File f1 = new File( testDir, "f1" );
        f1.createNewFile();
        File f2 = new File( testDir, "f2" );
        f2.createNewFile();

        File d1 = new File( testDir, "d1" );
        File d1d2 = new File( testDir, "d1/d2" );
        d1d2.mkdirs();
        File d1d2f1 = new File( d1d2, "f1" );
        d1d2f1.createNewFile();
        File d1d2f2 = new File( d1d2, "f2" );
        d1d2f2.createNewFile();

        ps.addAllFilesInDirectory( new File( "target/testAddAllFilesInDirectory" ), "123/" );
        assertEquals( "Unexpected PathSet size", 4, ps.size() );

        /*No changes after adding duplicates*/
        ps.addAllFilesInDirectory( new File( "target/testAddAllFilesInDirectory" ), "123/" );
        assertEquals( "Unexpected PathSet size", 4, ps.size() );

        /*Cleanup*/

        f1.delete();
        f2.delete();

        /*No changes after adding a subset of files*/
        ps.addAllFilesInDirectory( new File( "target/testAddAllFilesInDirectory" ), "123/" );
        assertEquals( "Unexpected PathSet size", 4, ps.size() );

        d1d2f1.delete();
        d1d2f2.delete();
        d1d2.delete();
        d1.delete();
        testDir.delete();

        assertTrue( ps.contains( "123/f1" ) );
        assertTrue( ps.contains( "/123/f1" ) );
        assertTrue( ps.contains( "123\\f1" ) );
        assertTrue( ps.contains( "123\\f2" ) );
        assertTrue( ps.contains( "\\123/d1\\d2/f1" ) );
        assertTrue( ps.contains( "123\\d1/d2\\f2" ) );
        assertFalse( ps.contains( "123\\f3" ) );
    }
}