test/jdk/java/util/Collection/RandomizedIteration.java

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

/*
 * @test
 * @bug     8201518
 * @key     randomness
 * @summary Ensure that randomized iteration order of unmodifiable sets
 *          and maps is actually randomized. Must be run othervm so that
 *          the per-VM-instance salt value differs.
 * @run main/othervm RandomizedIteration 0
 * @run main/othervm RandomizedIteration 1
 * @run main/othervm RandomizedIteration 2
 * @run main/othervm RandomizedIteration 3
 * @run main/othervm RandomizedIteration 4
 * @run main/othervm RandomizedIteration verify 5
 */

import java.io.IOException;
import java.io.PrintStream;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import static java.util.stream.Collectors.toUnmodifiableMap;

/**
 * Test of randomized iteration of unmodifiable sets and maps.
 *
 * Usage: RandomizedIteration n
 *            - writes files suffixed with 'n' containing set elements and map keys
 *              in iteration order
 *        RandomizedIteration "verify" count
 *            - reads files 0..count-1 and checks to ensure that their orders differ
 *
 * The idea is to generate several test files by invoking this test with an arg
 * of 0 through count-1. Then invoke the test once more with two args, the first being
 * the word "verify" and the second arg being the count. This will read all the generated
 * files and perform verification.
 *
 * The test is considered to pass if any of the runs result in different iteration
 * orders. The randomization is not actually very random, so over many runs there is
 * the possibility of a couple of the test files having the same order. That's ok, as
 * long as the iteration order is usually different. The test fails if *all* of the
 * iteration orders are the same.
 */
public class RandomizedIteration {
    /**
     * Generates a set and a map from the word array, and then writes
     * text files "set.#" and "map.#" containing the set elements and
     * map keys in iteration order.
     *
     * @param suffix number used for the file suffix
     */
    static void writeFiles(int suffix) throws IOException {
        try (PrintStream setOut = new PrintStream("set." + suffix)) {
            Set.of(WORDS)
               .forEach(setOut::println);
        }

        try (PrintStream mapOut = new PrintStream("map." + suffix)) {
            var map = Map.ofEntries(Arrays.stream(WORDS)
                                          .map(word -> Map.entry(word, ""))
                                          .toArray(Map.Entry<?, ?>[]::new));
            map.keySet()
               .forEach(mapOut::println);
        }
    }

    /**
     * Reads lines from each file derived from the prefix and index from 0..count-1
     * into a list, computes its hashcode, and returns a set of those hashcodes.
     * The hashcode of the list is order sensitive, so the same lines in a different
     * order should have different hashcodes.
     *
     * @param prefix the file prefix
     * @param count the number of files to read
     * @return a set of hashcodes of each file
     */
    static Set<Integer> readFiles(String prefix, int count) throws IOException {
        Set<Integer> hashes = new HashSet<>();
        for (int suffix = 0; suffix < count; suffix++) {
            String name = prefix + suffix;
            int hash = Files.readAllLines(Paths.get(name)).hashCode();
            System.out.println(name + ": " + hash);
            hashes.add(hash);
        }
        return hashes;
    }

    /**
     * Test main routine.
     *
     * @param args n | "verify" count
     * @throws IOException if an error occurred
     */
    public static void main(String[] args) throws IOException {
        if ("verify".equals(args[0])) {
            int count = Integer.parseInt(args[1]);
            System.out.println("Verifying " + count + " files.");
            Set<Integer> setHashes = readFiles("set.", count);
            Set<Integer> mapHashes = readFiles("map.", count);
            if (setHashes.size() > 1 && mapHashes.size() > 1) {
                System.out.println("Passed: differing iteration orders were detected.");
            } else {
                throw new AssertionError("FAILED: iteration order not randomized!");
            }
        } else {
            int suffix = Integer.parseInt(args[0]);
            System.out.println("Generating files: " + suffix);
            writeFiles(suffix);
        }
    }

    /**
     * List of 63 words of 22 or more letters from BSD /usr/share/dict/words.
     */
    static final String[] WORDS = {
        "anatomicophysiological",
        "anthropomorphologically",
        "aquopentamminecobaltic",
        "blepharoconjunctivitis",
        "blepharosphincterectomy",
        "cholecystenterorrhaphy",
        "cholecystoduodenostomy",
        "choledochoduodenostomy",
        "counterexcommunication",
        "dacryocystoblennorrhea",
        "dacryocystosyringotomy",
        "deanthropomorphization",
        "duodenocholecystostomy",
        "electroencephalography",
        "electrotelethermometer",
        "epididymodeferentectomy",
        "formaldehydesulphoxylate",
        "formaldehydesulphoxylic",
        "gastroenteroanastomosis",
        "hematospectrophotometer",
        "hexamethylenetetramine",
        "hexanitrodiphenylamine",
        "historicocabbalistical",
        "hydropneumopericardium",
        "hyperconscientiousness",
        "laparocolpohysterotomy",
        "lymphangioendothelioma",
        "macracanthrorhynchiasis",
        "microcryptocrystalline",
        "naphthylaminesulphonic",
        "nonrepresentationalism",
        "omnirepresentativeness",
        "pancreaticoduodenostomy",
        "pancreaticogastrostomy",
        "pathologicohistological",
        "pathologicopsychological",
        "pericardiomediastinitis",
        "phenolsulphonephthalein",
        "philosophicohistorical",
        "philosophicotheological",
        "photochronographically",
        "photospectroheliograph",
        "pneumohydropericardium",
        "pneumoventriculography",
        "polioencephalomyelitis",
        "Prorhipidoglossomorpha",
        "Pseudolamellibranchiata",
        "pseudolamellibranchiate",
        "pseudomonocotyledonous",
        "pyopneumocholecystitis",
        "scientificogeographical",
        "scientificophilosophical",
        "scleroticochorioiditis",
        "stereophotomicrography",
        "tetraiodophenolphthalein",
        "theologicoastronomical",
        "theologicometaphysical",
        "thymolsulphonephthalein",
        "thyroparathyroidectomize",
        "thyroparathyroidectomy",
        "transubstantiationalist",
        "ureterocystanastomosis",
        "zoologicoarchaeologist"
    };
}