1/*
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation.
8 *
9 * This code is distributed in the hope that it will be useful, but WITHOUT
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11 * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12 * version 2 for more details (a copy is included in the LICENSE file that
13 * accompanied this code).
14 *
15 * You should have received a copy of the GNU General Public License version
16 * 2 along with this work; if not, write to the Free Software Foundation,
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18 *
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20 * or visit www.oracle.com if you need additional information or have any
21 * questions.
22 */
23
24/*
25 * @test
26 * @bug 8008785
27 * @summary Ensure toArray() implementations return correct results.
28 * @author Mike Duigou
29 */
30import java.util.*;
31import java.util.concurrent.ConcurrentHashMap;
32import java.util.concurrent.ConcurrentSkipListMap;
33
34public class ToArray {
35
36    /**
37     * Number of elements per map.
38     */
39    private static final int TEST_SIZE = 5000;
40
41    private static void realMain(String[] args) throws Throwable {
42        Map<Integer, Long>[] maps = (Map<Integer, Long>[]) new Map[]{
43                    new HashMap<>(),
44                    new Hashtable<>(),
45                    new IdentityHashMap<>(),
46                    new LinkedHashMap<>(),
47                    new TreeMap<>(),
48                    new WeakHashMap<>(),
49                    new ConcurrentHashMap<>(),
50                    new ConcurrentSkipListMap<>()
51                };
52
53        // for each map type.
54        for (Map<Integer, Long> map : maps) {
55             try {
56                testMap(map);
57             } catch(Exception all) {
58                unexpected("Failed for " + map.getClass().getName(), all);
59             }
60        }
61    }
62
63    private static final Integer[] KEYS = new Integer[TEST_SIZE];
64
65    private static final Long[] VALUES = new Long[TEST_SIZE];
66
67    static {
68        for (int each = 0; each < TEST_SIZE; each++) {
69            KEYS[each]   = Integer.valueOf(each);
70            VALUES[each] = Long.valueOf(each + TEST_SIZE);
71        }
72    }
73
74
75    private static void testMap(Map<Integer, Long> map) {
76        System.out.println("Testing " + map.getClass());
77        System.out.flush();
78
79        // Fill the map
80        for (int each = 0; each < TEST_SIZE; each++) {
81            map.put(KEYS[each], VALUES[each]);
82        }
83
84        // check the keys
85        Object[] keys = map.keySet().toArray();
86        Arrays.sort(keys);
87
88        for(int each = 0; each < TEST_SIZE; each++) {
89            check( "unexpected key", keys[each] == KEYS[each]);
90        }
91
92        // check the values
93        Object[] values = map.values().toArray();
94        Arrays.sort(values);
95
96        for(int each = 0; each < TEST_SIZE; each++) {
97            check( "unexpected value", values[each] == VALUES[each]);
98        }
99
100        // check the entries
101        Map.Entry<Integer,Long>[] entries = map.entrySet().toArray(new Map.Entry[TEST_SIZE]);
102        Arrays.sort( entries,new Comparator<Map.Entry<Integer,Long>>() {
103                public int compare(Map.Entry<Integer,Long> o1, Map.Entry<Integer,Long> o2) {
104                        return o1.getKey().compareTo(o2.getKey());
105                }});
106
107        for(int each = 0; each < TEST_SIZE; each++) {
108            check( "unexpected entry", entries[each].getKey() == KEYS[each] && entries[each].getValue() == VALUES[each]);
109        }
110    }
111
112    //--------------------- Infrastructure ---------------------------
113    static volatile int passed = 0, failed = 0;
114
115    static void pass() {
116        passed++;
117    }
118
119    static void fail() {
120        failed++;
121        (new Error("Failure")).printStackTrace(System.err);
122    }
123
124    static void fail(String msg) {
125        failed++;
126        (new Error("Failure: " + msg)).printStackTrace(System.err);
127    }
128
129    static void abort() {
130        fail();
131        System.exit(1);
132    }
133
134    static void abort(String msg) {
135        fail(msg);
136        System.exit(1);
137    }
138
139    static void unexpected(String msg, Throwable t) {
140        System.err.println("Unexpected: " + msg);
141        unexpected(t);
142    }
143
144    static void unexpected(Throwable t) {
145        failed++;
146        t.printStackTrace(System.err);
147    }
148
149    static void check(boolean cond) {
150        if (cond) {
151            pass();
152        } else {
153            fail();
154        }
155    }
156
157    static void check(String desc, boolean cond) {
158        if (cond) {
159            pass();
160        } else {
161            fail(desc);
162        }
163    }
164
165    static void equal(Object x, Object y) {
166        if (Objects.equals(x, y)) {
167            pass();
168        } else {
169            fail(x + " not equal to " + y);
170        }
171    }
172
173    public static void main(String[] args) throws Throwable {
174        Thread.currentThread().setName(ToArray.class.getName());
175//        Thread.currentThread().setPriority(Thread.MAX_PRIORITY);
176        try {
177            realMain(args);
178        } catch (Throwable t) {
179            unexpected(t);
180        }
181
182        System.out.printf("%nPassed = %d, failed = %d%n%n", passed, failed);
183        if (failed > 0) {
184            throw new Error("Some tests failed");
185        }
186    }
187}
188