1/*
2 * Copyright (c) 2014, 2016, 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 */
23package jdk.incubator.http.internal.hpack;
24
25import org.testng.annotations.Test;
26
27import java.util.Objects;
28import java.util.Random;
29
30public final class TestHelper {
31
32    public static Random newRandom() {
33        long seed = Long.getLong("jdk.test.lib.random.seed", System.currentTimeMillis());
34        System.out.println("new java.util.Random(" + seed + ")");
35        return new Random(seed);
36    }
37
38    public static <T extends Throwable> T assertVoidThrows(Class<T> clazz, Block<?> code) {
39        return assertThrows(clazz, () -> {
40            code.run();
41            return null;
42        });
43    }
44
45    public static <T extends Throwable> T assertThrows(Class<T> clazz, ReturningBlock<?> code) {
46        Objects.requireNonNull(clazz, "clazz == null");
47        Objects.requireNonNull(code, "code == null");
48        try {
49            code.run();
50        } catch (Throwable t) {
51            if (clazz.isInstance(t)) {
52                return clazz.cast(t);
53            }
54            throw new AssertionError("Expected to catch exception of type "
55                    + clazz.getCanonicalName() + ", instead caught "
56                    + t.getClass().getCanonicalName(), t);
57
58        }
59        throw new AssertionError(
60                "Expected to catch exception of type " + clazz.getCanonicalName()
61                        + ", but caught nothing");
62    }
63
64    public static <T> T assertDoesNotThrow(ReturningBlock<T> code) {
65        Objects.requireNonNull(code, "code == null");
66        try {
67            return code.run();
68        } catch (Throwable t) {
69            throw new AssertionError(
70                    "Expected code block to exit normally, instead " +
71                            "caught " + t.getClass().getCanonicalName(), t);
72        }
73    }
74
75    public static void assertVoidDoesNotThrow(Block<?> code) {
76        Objects.requireNonNull(code, "code == null");
77        try {
78            code.run();
79        } catch (Throwable t) {
80            throw new AssertionError(
81                    "Expected code block to exit normally, instead " +
82                            "caught " + t.getClass().getCanonicalName(), t);
83        }
84    }
85
86
87    public static void assertExceptionMessageContains(Throwable t,
88                                                      CharSequence firstSubsequence,
89                                                      CharSequence... others) {
90        assertCharSequenceContains(t.getMessage(), firstSubsequence, others);
91    }
92
93    public static void assertCharSequenceContains(CharSequence s,
94                                                  CharSequence firstSubsequence,
95                                                  CharSequence... others) {
96        if (s == null) {
97            throw new NullPointerException("Exception message is null");
98        }
99        String str = s.toString();
100        String missing = null;
101        if (!str.contains(firstSubsequence.toString())) {
102            missing = firstSubsequence.toString();
103        } else {
104            for (CharSequence o : others) {
105                if (!str.contains(o.toString())) {
106                    missing = o.toString();
107                    break;
108                }
109            }
110        }
111        if (missing != null) {
112            throw new AssertionError("CharSequence '" + s + "'" + " does not "
113                    + "contain subsequence '" + missing + "'");
114        }
115    }
116
117    public interface ReturningBlock<T> {
118        T run() throws Throwable;
119    }
120
121    public interface Block<T> {
122        void run() throws Throwable;
123    }
124
125    // tests
126
127    @Test
128    public void assertThrows() {
129        assertThrows(NullPointerException.class, () -> ((Object) null).toString());
130    }
131
132    @Test
133    public void assertThrowsWrongType() {
134        try {
135            assertThrows(IllegalArgumentException.class, () -> ((Object) null).toString());
136        } catch (AssertionError e) {
137            Throwable cause = e.getCause();
138            String message = e.getMessage();
139            if (cause != null
140                    && cause instanceof NullPointerException
141                    && message != null
142                    && message.contains("instead caught")) {
143                return;
144            }
145        }
146        throw new AssertionError();
147    }
148
149    @Test
150    public void assertThrowsNoneCaught() {
151        try {
152            assertThrows(IllegalArgumentException.class, () -> null);
153        } catch (AssertionError e) {
154            Throwable cause = e.getCause();
155            String message = e.getMessage();
156            if (cause == null
157                    && message != null
158                    && message.contains("but caught nothing")) {
159                return;
160            }
161        }
162        throw new AssertionError();
163    }
164}
165