test/jdk/java/util/logging/FileHandlerPatternGeneration.java

/*
 * Copyright (c) 2017, 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.
 *
 * 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.
 */

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.security.*;
import java.util.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.logging.FileHandler;
import java.util.logging.LogManager;

/**
 * @test
 * @bug 8189953
 * @summary tests the pattern generation algorithm
 * @modules java.logging/java.util.logging:open
 * @run main/othervm FileHandlerPatternGeneration
 * @author danielfuchs
 */
public class FileHandlerPatternGeneration {

    /**
     * An array of strings where the elements at even indices are the input
     * to give to FileHandler::generate(pattern, count, generation, unique),
     * and the elements at the next odd index are a partially computed expected
     * output, where %t, %h, %u, %g and file separator still need to be replaced.
     * The final expected output is obtained by passing the partially computed
     * output to FileHandlerPatternGeneration::generateExpected
     * <p>
     * The test verifies that {@code
     *    FileHandler.generate(PATTERN[i], c, g, u).toString()
     * }
     * is equal to {@code
     *    FileHandlerPatternGeneration.generateExpected(PATTERN[i],
     *                                                  PATTERN[i+1],
     *                                                  c, g, u)
     * }
     */
    static final String[] PATTERNS = {
            "C:/Workspace/hoge.log",         "C:/Workspace/hoge.log",
            "C:/Workspace%g/hoge.log",       "C:/Workspace%g/hoge.log",
            "C:/%uWorkspace/hoge.log",       "C:/%uWorkspace/hoge.log",
            "C:/%uWorkspace%g/hoge.log",     "C:/%uWorkspace%g/hoge.log",
            "C:/Workspace/%ghoge.log",       "C:/Workspace/%ghoge.log",
            "C:/Workspace/%ghoge%u.log",     "C:/Workspace/%ghoge%u.log",
            "C:/Workspace-%g/hoge.log",      "C:/Workspace-%g/hoge.log",
            "C:/Work%hspace/hoge.log",       "%h/space/hoge.log",
            "C:/Works%tpace%g/hoge.log",     "%t/pace%g/hoge.log",
            "C:/%uWork%hspace/hoge.log",     "%h/space/hoge.log",
            "C:/%uWorkspace%g/%thoge.log",   "%t/hoge.log",
            "C:/Workspace/%g%h%%hoge.log",   "%h/%%hoge.log",
            "C:/Work%h%%hspace/hoge.log",    "%h/%%hspace/hoge.log",
            "C:/Works%t%%hpace%g/hoge.log",  "%t/%%hpace%g/hoge.log",
            "C:/%uWork%h%%tspace/hoge.log",  "%h/%%tspace/hoge.log",
            "C:/%uWorkspace%g/%t%%hoge.log", "%t/%%hoge.log",
            "C:/Workspace/%g%h%%hoge.log",   "%h/%%hoge.log",
            "ahaha",                         "ahaha",
            "ahaha/ahabe",                   "ahaha/ahabe",
            "../ahaha/ahabe",                "../ahaha/ahabe",
            "/x%ty/w/hoge.log",              "%t/y/w/hoge.log",
            "/x/%ty/w/hoge.log",             "%t/y/w/hoge.log",
            "/x%t/y/w/hoge.log",             "%t/y/w/hoge.log",
            "/x/%t/y/w/hoge.log",            "%t/y/w/hoge.log",
            "%ty/w/hoge.log",                "%t/y/w/hoge.log",
            "%t/y/w/hoge.log",               "%t/y/w/hoge.log",
            "/x%hy/w/hoge.log",              "%h/y/w/hoge.log",
            "/x/%hy/w/hoge.log",             "%h/y/w/hoge.log",
            "/x%h/y/w/hoge.log",             "%h/y/w/hoge.log",
            "/x/%h/y/w/hoge.log",            "%h/y/w/hoge.log",
            "%hy/w/hoge.log",                "%h/y/w/hoge.log",
            "%h/y/w/hoge.log",               "%h/y/w/hoge.log",
            "ahaha-%u-%g",                   "ahaha-%u-%g",
            "ahaha-%g/ahabe-%u",             "ahaha-%g/ahabe-%u",
            "../ahaha-%u/ahabe",             "../ahaha-%u/ahabe",
            "/x%ty/w/hoge-%g.log",           "%t/y/w/hoge-%g.log",
            "/x/%ty/w/hoge-%u.log",          "%t/y/w/hoge-%u.log",
            "%u-%g/x%t/y/w/hoge.log",        "%t/y/w/hoge.log",
            "/x/%g%t%u/y/w/hoge.log",        "%t/%u/y/w/hoge.log",
            "%ty/w-%g/hoge.log",             "%t/y/w-%g/hoge.log",
            "%t/y/w-%u/hoge.log",            "%t/y/w-%u/hoge.log",
            "/x%hy/%u-%g-w/hoge.log",        "%h/y/%u-%g-w/hoge.log",
            "/x/%hy/w-%u-%g/hoge.log",       "%h/y/w-%u-%g/hoge.log",
            "/x%h/y/w/%u-%ghoge.log",        "%h/y/w/%u-%ghoge.log",
            "/x/%h/y/w/hoge-%u-%g.log",      "%h/y/w/hoge-%u-%g.log",
            "%hy/w/%u-%g-hoge.log",          "%h/y/w/%u-%g-hoge.log",
            "%h/y/w/hoge-%u-%g.log",         "%h/y/w/hoge-%u-%g.log",
            "/x/y/z/hoge-%u.log",            "/x/y/z/hoge-%u.log",
    };

    // the (count, generation, unique) parameters to pass to
    // FileHandler.generate(pattern, count, generation, unique)
    static final int[][] GENERATIONS = {
        {0, 0, 0},
        {0, 1, 0},
        {0, 1, 1},
        {1, 1, 0},
        {1, 1, 1},
        {1, 1, 2},
        {1, 2, 3},
        {3, 4, 0},
        {3, 4, 1},
        {3, 4, 2},
        {3, 0, 5},
        {3, 1, 5},
        {3, 2, 5},
    };

    static final Class<FileHandler> FILE_HANDLER_CLASS = FileHandler.class;
    static final Method GENERATE;
    static final String USER_HOME;
    static final String TMP;
    static {
        Method generate;
        try {
           generate = FILE_HANDLER_CLASS.getDeclaredMethod("generate",
                                                            String.class,
                                                            int.class,
                                                            int.class,
                                                            int.class);
           generate.setAccessible(true);
        } catch (Exception e) {
            throw new ExceptionInInitializerError(e);
        }
        GENERATE = generate;
        USER_HOME = System.getProperty("user.home");
        TMP = System.getProperty("java.io.tmpdir", USER_HOME);
    }

    public static void main(String... args) throws Throwable {

        for (int i=0; i < PATTERNS.length; i+=2) {
            String s = PATTERNS[i];
            String partial = PATTERNS[i+1];
            System.out.println("generate: " + s);
            for (int[] gen : GENERATIONS) {
                String expected = generateExpected(s, partial, gen[0], gen[1], gen[2]);
                String output = generate(s, gen[0], gen[1], gen[2]).toString();
                System.out.println("\t" + Arrays.toString(gen)+ ": " + output);
                if (!expected.equals(output)) {
                    throw new RuntimeException("test failed for \""
                            + s +"\" " + Arrays.toString(gen) + ": "
                            + "\n\tgenerated: \"" + output +"\""
                            + "\n\t expected: \"" + expected +"\"");
                }
            }
        }

    }

    // Strip the trailing separator from the string, if present
    static String stripTrailingSeparator(String s) {
        if (s.endsWith("/")) {
            return s.substring(0, s.length() -1);
        } else if (s.endsWith(File.separator)) {
            return s.substring(0, s.length() - File.separator.length());
        } else {
            return s;
        }
    }

    /**
     * Compute the final expected output from a partially computed output found
     * at PATTERNS[i+1]
     * @param s           The pattern string, found at PATTERN[i]
     *                    (with i % 2 == 0)
     * @param partial     The partially computed output, found at PATTERN[i+1]
     * @param count       The count parameter given to FileHandler::generate
     * @param generation  The generation parameter given to FileHandler::generate
     * @param unique      The unique parameter given to FileHandler::generate
     * @return  The expected output that FileHandler.generate(s, count, gen, unique)
     *          should produce.
     */
    static String generateExpected(String s, String partial,
                                   int count, int generation, int unique)
    {
        boolean sawu = s.replace("%%", "$$$$").contains("%u");
        boolean sawg = s.replace("%%", "$$$$").contains("%g");
        String result = partial.replace("%%", "$$$$");
        String tmp = stripTrailingSeparator(TMP);
        String home = stripTrailingSeparator(USER_HOME);
        result = result.replace("%h", home);
        result = result.replace("%t", tmp);
        result = result.replace("%g", String.valueOf(generation));
        result = result.replace("%u", String.valueOf(unique));
        result = result.replace("$$$$", "%");
        result = result.replace("/", File.separator);
        if (count > 1 && !sawg) {
            result = result + "." + generation;
        }
        if (unique > 0 && !sawu) {
            result = result + "." + unique;
        }
        return result;
    }

    // Calls FileHandler.generate(s, count, generation, unique) through reflection
    static File generate(String s, int count, int generation, int unique)
            throws Throwable
    {
        try {
            return (File) GENERATE.invoke(null, s, count, generation, unique);
        } catch (InvocationTargetException e) {
            throw e.getCause();
        }
    }
}