Skip to main content
summaryrefslogtreecommitdiffstats
blob: bcc683ac7db593ead8b1806c46b6682b454e01c4 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
/*******************************************************************************
 * Copyright (c) 2000, 2009 IBM Corporation and others.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jface.text;


/**
 * <code>Assert</code> is useful for for embedding runtime sanity checks
 * in code. The static predicate methods all test a condition and throw some
 * type of unchecked exception if the condition does not hold.
 * <p>
 * Assertion failure exceptions, like most runtime exceptions, are
 * thrown when something is misbehaving. Assertion failures are invariably
 * unspecified behavior; consequently, clients should never rely on
 * these being thrown (or not thrown). <b>If you find yourself in the
 * position where you need to catch an assertion failure, you have most
 * certainly written your program incorrectly.</b>
 * </p>
 * <p>
 * Note that an <code>assert</code> statement is slated to be added to the
 * Java language in JDK 1.4, rending this class obsolete.
 * </p>
 *
 * @deprecated As of 3.3, replaced by {@link org.eclipse.core.runtime.Assert}
 * @noinstantiate This class is not intended to be instantiated by clients.
 *
 * @noreference This class is planned to be deleted, see Bug 528191
 *
 */
@Deprecated
public final class Assert {

		/**
		 * <code>AssertionFailedException</code> is a runtime exception thrown
		 * by some of the methods in <code>Assert</code>.
		 * <p>
		 * This class is not declared public to prevent some misuses; programs that catch
		 * or otherwise depend on assertion failures are susceptible to unexpected
		 * breakage when assertions in the code are added or removed.
		 * </p>
		 * <p>
		 * This class is not intended to be serialized.
		 * </p>
		 */
		private static class AssertionFailedException extends RuntimeException {

			/**
			 * Serial version UID for this class.
			 * <p>
			 * Note: This class is not intended to be serialized.
			 * </p>
			 * @since 3.1
			 */
			private static final long serialVersionUID= 3689918374733886002L;

			/**
			 * Constructs a new exception with the given message.
			 *
			 * @param detail the detailed message
			 */
			public AssertionFailedException(String detail) {
			    super(detail);
			}
		}

	/* This class is not intended to be instantiated. */
	private Assert() {
	}

	/**
	 * Asserts that an argument is legal. If the given boolean is
	 * not <code>true</code>, an <code>IllegalArgumentException</code>
	 * is thrown.
	 *
	 * @param expression the outcome of the check
	 * @return <code>true</code> if the check passes (does not return
	 *    if the check fails)
	 * @exception IllegalArgumentException if the legality test failed
	 */
	public static boolean isLegal(boolean expression) {
		// succeed as quickly as possible
		if (expression) {
			return true;
		}
		return isLegal(expression, "");//$NON-NLS-1$
	}

	/**
	 * Asserts that an argument is legal. If the given boolean is
	 * not <code>true</code>, an <code>IllegalArgumentException</code>
	 * is thrown.
	 * The given message is included in that exception, to aid debugging.
	 *
	 * @param expression the outcome of the check
	 * @param message the message to include in the exception
	 * @return <code>true</code> if the check passes (does not return
	 *    if the check fails)
	 * @exception IllegalArgumentException if the legality test failed
	 */
	public static boolean isLegal(boolean expression, String message) {
		if (!expression)
			throw new IllegalArgumentException("assertion failed; " + message); //$NON-NLS-1$
		return expression;
	}

	/**
	 * Asserts that the given object is not <code>null</code>. If this
	 * is not the case, some kind of unchecked exception is thrown.
	 * <p>
	 * As a general rule, parameters passed to API methods must not be
	 * <code>null</code> unless <b>explicitly</b> allowed in the method's
	 * specification. Similarly, results returned from API methods are never
	 * <code>null</code> unless <b>explicitly</b> allowed in the method's
	 * specification. Implementations are encouraged to make regular use of
	 * <code>Assert.isNotNull</code> to ensure that <code>null</code>
	 * parameters are detected as early as possible.
	 * </p>
	 *
	 * @param object the value to test
	 * @exception RuntimeException an unspecified unchecked exception if the object
	 *   is <code>null</code>
	 */
	public static void isNotNull(Object object) {
		// succeed as quickly as possible
		if (object != null) {
			return;
		}
		isNotNull(object, "");//$NON-NLS-1$
	}

	/**
	 * Asserts that the given object is not <code>null</code>. If this
	 * is not the case, some kind of unchecked exception is thrown.
	 * The given message is included in that exception, to aid debugging.
	 * <p>
	 * As a general rule, parameters passed to API methods must not be
	 * <code>null</code> unless <b>explicitly</b> allowed in the method's
	 * specification. Similarly, results returned from API methods are never
	 * <code>null</code> unless <b>explicitly</b> allowed in the method's
	 * specification. Implementations are encouraged to make regular use of
	 * <code>Assert.isNotNull</code> to ensure that <code>null</code>
	 * parameters are detected as early as possible.
	 * </p>
	 *
	 * @param object the value to test
	 * @param message the message to include in the exception
	 * @exception RuntimeException an unspecified unchecked exception if the object
	 *   is <code>null</code>
	 */
	public static void isNotNull(Object object, String message) {
		if (object == null)
			throw new AssertionFailedException("null argument;" + message);//$NON-NLS-1$
	}

	/**
	 * Asserts that the given boolean is <code>true</code>. If this
	 * is not the case, some kind of unchecked exception is thrown.
	 *
	 * @param expression the outcome of the check
	 * @return <code>true</code> if the check passes (does not return
	 *    if the check fails)
	 */
	public static boolean isTrue(boolean expression) {
		// succeed as quickly as possible
		if (expression) {
			return true;
		}
		return isTrue(expression, "");//$NON-NLS-1$
	}

	/**
	 * Asserts that the given boolean is <code>true</code>. If this
	 * is not the case, some kind of unchecked exception is thrown.
	 * The given message is included in that exception, to aid debugging.
	 *
	 * @param expression the outcome of the check
	 * @param message the message to include in the exception
	 * @return <code>true</code> if the check passes (does not return
	 *    if the check fails)
	 */
	public static boolean isTrue(boolean expression, String message) {
		if (!expression)
			throw new AssertionFailedException("Assertion failed: "+message);//$NON-NLS-1$
		return expression;
	}
}

Back to the top