Mercurial > hg > truffle

annotate test/testlibrary/com/oracle/java/testlibrary/Asserts.java @ 12063:1a8fb39bdbc4

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
8014659: NPG: performance counters for compressed klass space Reviewed-by: mgerdin, coleenp, hseigel, jmasa, ctornqvi
author ehelin
date Wed, 07 Aug 2013 16:47:32 +0200
parents
children a48e16541e6b
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
12063
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
1 /*
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
2 * Copyright (c) 2013, Oracle and/or its affiliates. All rights reserved.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
4 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
5 * This code is free software; you can redistribute it and/or modify it
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
6 * under the terms of the GNU General Public License version 2 only, as
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
7 * published by the Free Software Foundation.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
8 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
9 * This code is distributed in the hope that it will be useful, but WITHOUT
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
10 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
11 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
12 * version 2 for more details (a copy is included in the LICENSE file that
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
13 * accompanied this code).
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
14 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
15 * You should have received a copy of the GNU General Public License version
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
16 * 2 along with this work; if not, write to the Free Software Foundation,
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
17 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
18 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
19 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
20 * or visit www.oracle.com if you need additional information or have any
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
21 * questions.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
22 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
23
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
24 package com.oracle.java.testlibrary;
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
25
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
26 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
27 * Asserts that can be used for verifying assumptions in tests.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
28 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
29 * An assertion will throw a {@link RuntimeException} if the assertion isn't
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
30 * valid. All the asserts can be imported into a test by using a static
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
31 * import:
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
32 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
33 * <pre>
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
34 * {@code
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
35 * import static com.oracle.java.testlibrary.Asserts.*;
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
36 * }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
37 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
38 * Always provide a message describing the assumption if the line number of the
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
39 * failing assertion isn't enough to understand why the assumption failed. For
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
40 * example, if the assertion is in a loop or in a method that is called
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
41 * multiple times, then the line number won't provide enough context to
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
42 * understand the failure.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
43 * </pre>
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
44 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
45 public class Asserts {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
46
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
47 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
48 * Shorthand for {@link #assertLessThan(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
49 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
50 * @see #assertLessThan(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
51 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
52 public static <T extends Comparable<T>> void assertLT(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
53 assertLessThan(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
54 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
55
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
56 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
57 * Shorthand for {@link #assertLessThan(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
58 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
59 * @see #assertLessThan(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
60 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
61 public static <T extends Comparable<T>> void assertLT(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
62 assertLessThan(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
63 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
64
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
65 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
66 * Calls {@link #assertLessThan(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
67 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
68 * @see #assertLessThan(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
69 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
70 public static <T extends Comparable<T>> void assertLessThan(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
71 String msg = "Expected that " + format(lhs) + " < " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
72 assertLessThan(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
73 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
74
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
75 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
76 * Asserts that {@code lhs} is less than {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
77 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
78 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
79 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
80 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
81 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
82 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
83 public static <T extends Comparable<T>>void assertLessThan(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
84 assertTrue(compare(lhs, rhs, msg) < 0, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
85 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
86
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
87 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
88 * Shorthand for {@link #assertLessThanOrEqual(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
89 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
90 * @see #assertLessThanOrEqual(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
91 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
92 public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
93 assertLessThanOrEqual(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
94 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
95
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
96 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
97 * Shorthand for {@link #assertLessThanOrEqual(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
98 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
99 * @see #assertLessThanOrEqual(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
100 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
101 public static <T extends Comparable<T>> void assertLTE(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
102 assertLessThanOrEqual(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
103 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
104
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
105 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
106 * Calls {@link #assertLessThanOrEqual(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
107 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
108 * @see #assertLessThanOrEqual(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
109 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
110 public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
111 String msg = "Expected that " + format(lhs) + " <= " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
112 assertLessThanOrEqual(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
113 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
114
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
115 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
116 * Asserts that {@code lhs} is less than or equal to {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
117 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
118 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
119 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
120 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
121 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
122 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
123 public static <T extends Comparable<T>> void assertLessThanOrEqual(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
124 assertTrue(compare(lhs, rhs, msg) <= 0, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
125 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
126
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
127 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
128 * Shorthand for {@link #assertEquals(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
129 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
130 * @see #assertEquals(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
131 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
132 public static void assertEQ(Object lhs, Object rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
133 assertEquals(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
134 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
135
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
136 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
137 * Shorthand for {@link #assertEquals(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
138 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
139 * @see #assertEquals(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
140 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
141 public static void assertEQ(Object lhs, Object rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
142 assertEquals(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
143 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
144
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
145 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
146 * Calls {@link #assertEquals(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
147 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
148 * @see #assertEquals(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
149 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
150 public static void assertEquals(Object lhs, Object rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
151 String msg = "Expected " + format(lhs) + " to equal " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
152 assertEquals(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
153 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
154
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
155 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
156 * Asserts that {@code lhs} is equal to {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
157 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
158 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
159 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
160 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
161 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
162 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
163 public static void assertEquals(Object lhs, Object rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
164 if (lhs == null) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
165 if (rhs != null) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
166 error(msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
167 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
168 } else {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
169 assertTrue(lhs.equals(rhs), msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
170 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
171 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
172
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
173 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
174 * Shorthand for {@link #assertGreaterThanOrEqual(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
175 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
176 * @see #assertGreaterThanOrEqual(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
177 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
178 public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
179 assertGreaterThanOrEqual(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
180 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
181
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
182 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
183 * Shorthand for {@link #assertGreaterThanOrEqual(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
184 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
185 * @see #assertGreaterThanOrEqual(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
186 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
187 public static <T extends Comparable<T>> void assertGTE(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
188 assertGreaterThanOrEqual(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
189 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
190
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
191 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
192 * Calls {@link #assertGreaterThanOrEqual(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
193 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
194 * @see #assertGreaterThanOrEqual(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
195 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
196 public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
197 String msg = "Expected that " + format(lhs) + " >= " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
198 assertGreaterThanOrEqual(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
199 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
200
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
201 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
202 * Asserts that {@code lhs} is greater than or equal to {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
203 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
204 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
205 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
206 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
207 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
208 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
209 public static <T extends Comparable<T>> void assertGreaterThanOrEqual(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
210 assertTrue(compare(lhs, rhs, msg) >= 0, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
211 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
212
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
213 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
214 * Shorthand for {@link #assertGreaterThan(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
215 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
216 * @see #assertGreaterThan(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
217 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
218 public static <T extends Comparable<T>> void assertGT(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
219 assertGreaterThan(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
220 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
221
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
222 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
223 * Shorthand for {@link #assertGreaterThan(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
224 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
225 * @see #assertGreaterThan(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
226 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
227 public static <T extends Comparable<T>> void assertGT(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
228 assertGreaterThan(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
229 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
230
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
231 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
232 * Calls {@link #assertGreaterThan(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
233 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
234 * @see #assertGreaterThan(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
235 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
236 public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
237 String msg = "Expected that " + format(lhs) + " > " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
238 assertGreaterThan(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
239 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
240
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
241 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
242 * Asserts that {@code lhs} is greater than {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
243 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
244 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
245 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
246 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
247 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
248 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
249 public static <T extends Comparable<T>> void assertGreaterThan(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
250 assertTrue(compare(lhs, rhs, msg) > 0, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
251 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
252
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
253 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
254 * Shorthand for {@link #assertNotEquals(T, T)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
255 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
256 * @see #assertNotEquals(T, T)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
257 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
258 public static void assertNE(Object lhs, Object rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
259 assertNotEquals(lhs, rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
260 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
261
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
262 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
263 * Shorthand for {@link #assertNotEquals(T, T, String)}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
264 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
265 * @see #assertNotEquals(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
266 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
267 public static void assertNE(Object lhs, Object rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
268 assertNotEquals(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
269 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
270
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
271 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
272 * Calls {@link #assertNotEquals(T, T, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
273 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
274 * @see #assertNotEquals(T, T, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
275 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
276 public static void assertNotEquals(Object lhs, Object rhs) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
277 String msg = "Expected " + format(lhs) + " to not equal " + format(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
278 assertNotEquals(lhs, rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
279 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
280
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
281 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
282 * Asserts that {@code lhs} is not equal to {@code rhs}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
283 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
284 * @param lhs The left hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
285 * @param rhs The right hand side of the comparison.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
286 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
287 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
288 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
289 public static void assertNotEquals(Object lhs, Object rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
290 if (lhs == null) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
291 if (rhs == null) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
292 error(msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
293 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
294 } else {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
295 assertFalse(lhs.equals(rhs), msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
296 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
297 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
298
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
299 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
300 * Calls {@link #assertNull(Object, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
301 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
302 * @see #assertNull(Object, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
303 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
304 public static void assertNull(Object o) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
305 assertNull(o, "Expected " + format(o) + " to be null");
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
306 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
307
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
308 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
309 * Asserts that {@code o} is null.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
310 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
311 * @param o The reference assumed to be null.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
312 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
313 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
314 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
315 public static void assertNull(Object o, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
316 assertEquals(o, null, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
317 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
318
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
319 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
320 * Calls {@link #assertNotNull(Object, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
321 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
322 * @see #assertNotNull(Object, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
323 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
324 public static void assertNotNull(Object o) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
325 assertNotNull(o, "Expected non null reference");
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
326 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
327
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
328 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
329 * Asserts that {@code o} is <i>not</i> null.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
330 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
331 * @param o The reference assumed <i>not</i> to be null,
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
332 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
333 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
334 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
335 public static void assertNotNull(Object o, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
336 assertNotEquals(o, null, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
337 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
338
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
339 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
340 * Calls {@link #assertFalse(boolean, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
341 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
342 * @see #assertFalse(boolean, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
343 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
344 public static void assertFalse(boolean value) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
345 assertFalse(value, "Expected value to be false");
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
346 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
347
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
348 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
349 * Asserts that {@code value} is {@code false}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
350 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
351 * @param value The value assumed to be false.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
352 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
353 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
354 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
355 public static void assertFalse(boolean value, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
356 assertTrue(!value, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
357 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
358
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
359 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
360 * Calls {@link #assertTrue(boolean, String)} with a default message.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
361 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
362 * @see #assertTrue(boolean, String)
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
363 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
364 public static void assertTrue(boolean value) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
365 assertTrue(value, "Expected value to be true");
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
366 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
367
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
368 /**
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
369 * Asserts that {@code value} is {@code true}.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
370 *
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
371 * @param value The value assumed to be true.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
372 * @param msg A description of the assumption.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
373 * @throws RuntimeException if the assertion isn't valid.
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
374 */
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
375 public static void assertTrue(boolean value, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
376 if (!value) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
377 error(msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
378 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
379 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
380
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
381 private static <T extends Comparable<T>> int compare(T lhs, T rhs, String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
382 assertNotNull(lhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
383 assertNotNull(rhs, msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
384 return lhs.compareTo(rhs);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
385 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
386
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
387 private static String format(Object o) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
388 return o == null? "null" : o.toString();
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
389 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
390
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
391 private static void error(String msg) {
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
392 throw new RuntimeException(msg);
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
393 }
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
394
1a8fb39bdbc4 8014659: NPG: performance counters for compressed klass space
ehelin
parents:
diff changeset
395 }