/*

 * Copyright 2008-2009 Sun Microsystems, Inc.  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.

 *

 * 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.com if you need additional information or

 * have any questions.

 */

/* @test

 * @bug 4313887

 * @summary Unit test for java.nio.file.DirectoryStreamFilters

 * @library ..

 */

import java.nio.file.*;

import static java.nio.file.DirectoryStreamFilters.*;

import java.nio.file.attribute.Attributes;

import java.io.*;

import java.util.*;

public class Filters {

    static final Random rand = new Random();

    // returns a filter that only accepts files that are larger than a given size

    static DirectoryStream.Filter<FileRef> newMinimumSizeFilter(final long min) {

        return new DirectoryStream.Filter<FileRef>() {

            public boolean accept(FileRef file) {

                try {

                    long size = Attributes.readBasicFileAttributes(file).size();

                    return size >= min;

                } catch (IOException e) {

                    throw new IOError(e);

                }

            }

        };

    }

    // returns a filter that only accepts files that are matched by a given glob

    static DirectoryStream.Filter<Path> newGlobFilter(final String glob) {

        return new DirectoryStream.Filter<Path>() {

            PathMatcher matcher = FileSystems.getDefault().getPathMatcher("glob:"+ glob);

            public boolean accept(Path file) {

                return matcher.matches(file.getName());

            }

        };

    }

    static final int BIG_FILE_THRESHOLD = 8192;

    static int totalCount;

    static int htmlCount;

    static int bigAndHtmlCount;

    static int bigOrHtmlCount;

    // generates random files in the test directory and initializes the counts

    static void setup(Path dir) throws IOException {

        // create 10-26 files.

        totalCount = 10 + rand.nextInt(17);

        char firstChar = 'A';

        for (int i=0; i<totalCount; i++) {

            boolean isHtml = rand.nextBoolean();

            boolean isBig = rand.nextBoolean();

            if (isHtml) {

                htmlCount++;

                if (isBig) bigAndHtmlCount++;

            }

            if (isHtml || isBig)

                bigOrHtmlCount++;

            String name;

            if (isHtml) {

                name = firstChar + ".html";

            } else {

                name = firstChar + ".tmp";

            }

            firstChar++;

            int size = rand.nextInt(BIG_FILE_THRESHOLD);

            if (isBig)

                size += BIG_FILE_THRESHOLD;

            Path file = dir.resolve(name);

            OutputStream out = file.newOutputStream();

            try {

                if (size > 0)

                    out.write(new byte[size]);

            } finally {

                out.close();

            }

            System.out.format("Created %s, size %d byte(s)\n", name, size);

        }

    }

    static boolean isHtml(Path file) {

        return file.toString().endsWith(".html");

    }

    static boolean isBig(Path file) throws IOException {

        long size = Attributes.readBasicFileAttributes(file).size();

        return size >= BIG_FILE_THRESHOLD;

    }

    static void checkCount(int expected, int actual) {

        if (actual != expected)

            throw new RuntimeException("'" + expected +

                "' entries expected, actual: " + actual);

    }

    static void doTests(Path dir) throws IOException {

        final List<DirectoryStream.Filter<Path>> emptyList = Collections.emptyList();

        // list containing two filters

        List<DirectoryStream.Filter<? super Path>> filters =

            new ArrayList<DirectoryStream.Filter<? super Path>>();

        filters.add(newMinimumSizeFilter(BIG_FILE_THRESHOLD));

        filters.add(newGlobFilter("*.html"));

        int accepted;

        DirectoryStream<Path> stream;

        System.out.println("Test: newContentTypeFilter");

        accepted = 0;

        stream = dir.newDirectoryStream(newContentTypeFilter("text/html"));

        try {

            for (Path entry: stream) {

                if (!isHtml(entry))

                    throw new RuntimeException("html file expected");

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(htmlCount, accepted);

        System.out.println("Test: allOf with list of filters");

        accepted = 0;

        stream = dir.newDirectoryStream(allOf(filters));

        try {

            for (Path entry: stream) {

                if (!isHtml(entry))

                    throw new RuntimeException("html file expected");

                if (!isBig(entry))

                    throw new RuntimeException("big file expected");

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(bigAndHtmlCount, accepted);

        System.out.println("Test: allOf with empty list");

        accepted = 0;

        stream = dir.newDirectoryStream(allOf(emptyList));

        try {

            for (Path entry: stream) {

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(totalCount, accepted);

        System.out.println("Test: anyOf with list of filters");

        accepted = 0;

        stream = dir.newDirectoryStream(anyOf(filters));

        try {

            for (Path entry: stream) {

                if (!isHtml(entry) && !isBig(entry))

                    throw new RuntimeException("html or big file expected");

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(bigOrHtmlCount, accepted);

        System.out.println("Test: anyOf with empty list");

        accepted = 0;

        stream = dir.newDirectoryStream(anyOf(emptyList));

        try {

            for (Path entry: stream) {

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(0, accepted);

        System.out.println("Test: complementOf");

        accepted = 0;

        stream = dir.newDirectoryStream(complementOf(newGlobFilter("*.html")));

        try {

            for (Path entry: stream) {

                accepted++;

            }

        } finally {

            stream.close();

        }

        checkCount(totalCount-htmlCount, accepted);

        System.out.println("Test: nulls");

        try {

            newContentTypeFilter(null);

            throw new RuntimeException("NullPointerException expected");

        } catch (NullPointerException npe) { }

        try {

            allOf(null);

            throw new RuntimeException("NullPointerException expected");

        } catch (NullPointerException npe) { }

        try {

            anyOf(null);

            throw new RuntimeException("NullPointerException expected");

        } catch (NullPointerException npe) { }

        try {

            complementOf(null);

            throw new RuntimeException("NullPointerException expected");

        } catch (NullPointerException npe) { }

    }

    public static void main(String[] args) throws IOException {

        Path dir = TestUtil.createTemporaryDirectory();

        try {

            setup(dir);

            doTests(dir);

        } finally {

            TestUtil.removeAll(dir);

        }

    }

}