1/*
2 * Copyright (C) 2016 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License
15 */
16
17package com.android.dialer.common;
18
19import android.os.Looper;
20import android.support.annotation.NonNull;
21import android.support.annotation.Nullable;
22import javax.annotation.CheckReturnValue;
23
24/** Assertions which will result in program termination unless disabled by flags. */
25public class Assert {
26
27  private static boolean areThreadAssertsEnabled = true;
28
29  public static void setAreThreadAssertsEnabled(boolean areThreadAssertsEnabled) {
30    Assert.areThreadAssertsEnabled = areThreadAssertsEnabled;
31  }
32
33  public static boolean areThreadAssertsEnabled() {
34    return areThreadAssertsEnabled;
35  }
36
37  /**
38   * Called when a truly exceptional case occurs.
39   *
40   * @throws AssertionError
41   * @deprecated Use throw Assert.create*FailException() instead.
42   */
43  @Deprecated
44  public static void fail() {
45    throw new AssertionError("Fail");
46  }
47
48  /**
49   * Called when a truly exceptional case occurs.
50   *
51   * @param reason the optional reason to supply as the exception message
52   * @throws AssertionError
53   * @deprecated Use throw Assert.create*FailException() instead.
54   */
55  @Deprecated
56  public static void fail(String reason) {
57    throw new AssertionError(reason);
58  }
59
60  @CheckReturnValue
61  public static AssertionError createAssertionFailException(String msg) {
62    return new AssertionError(msg);
63  }
64
65  @CheckReturnValue
66  public static UnsupportedOperationException createUnsupportedOperationFailException() {
67    return new UnsupportedOperationException();
68  }
69
70  @CheckReturnValue
71  public static UnsupportedOperationException createUnsupportedOperationFailException(String msg) {
72    return new UnsupportedOperationException(msg);
73  }
74
75  @CheckReturnValue
76  public static IllegalStateException createIllegalStateFailException() {
77    return new IllegalStateException();
78  }
79
80  @CheckReturnValue
81  public static IllegalStateException createIllegalStateFailException(String msg) {
82    return new IllegalStateException(msg);
83  }
84
85  /**
86   * Ensures the truth of an expression involving one or more parameters to the calling method.
87   *
88   * @param expression a boolean expression
89   * @throws IllegalArgumentException if {@code expression} is false
90   */
91  public static void checkArgument(boolean expression) {
92    checkArgument(expression, null);
93  }
94
95  /**
96   * Ensures the truth of an expression involving one or more parameters to the calling method.
97   *
98   * @param expression a boolean expression
99   * @param messageTemplate the message to log, possible with format arguments.
100   * @param args optional arguments to be used in the formatted string.
101   * @throws IllegalArgumentException if {@code expression} is false
102   */
103  public static void checkArgument(
104      boolean expression, @Nullable String messageTemplate, Object... args) {
105    if (!expression) {
106      throw new IllegalArgumentException(format(messageTemplate, args));
107    }
108  }
109
110  /**
111   * Ensures the truth of an expression involving the state of the calling instance, but not
112   * involving any parameters to the calling method.
113   *
114   * @param expression a boolean expression
115   * @throws IllegalStateException if {@code expression} is false
116   */
117  public static void checkState(boolean expression) {
118    checkState(expression, null);
119  }
120
121  /**
122   * Ensures the truth of an expression involving the state of the calling instance, but not
123   * involving any parameters to the calling method.
124   *
125   * @param expression a boolean expression
126   * @param messageTemplate the message to log, possible with format arguments.
127   * @param args optional arguments to be used in the formatted string.
128   * @throws IllegalStateException if {@code expression} is false
129   */
130  public static void checkState(
131      boolean expression, @Nullable String messageTemplate, Object... args) {
132    if (!expression) {
133      throw new IllegalStateException(format(messageTemplate, args));
134    }
135  }
136
137  /**
138   * Ensures that an object reference passed as a parameter to the calling method is not null.
139   *
140   * @param reference an object reference
141   * @return the non-null reference that was validated
142   * @throws NullPointerException if {@code reference} is null
143   */
144  @NonNull
145  public static <T> T isNotNull(@Nullable T reference) {
146    return isNotNull(reference, null);
147  }
148
149  /**
150   * Ensures that an object reference passed as a parameter to the calling method is not null.
151   *
152   * @param reference an object reference
153   * @param messageTemplate the message to log, possible with format arguments.
154   * @param args optional arguments to be used in the formatted string.
155   * @return the non-null reference that was validated
156   * @throws NullPointerException if {@code reference} is null
157   */
158  @NonNull
159  public static <T> T isNotNull(
160      @Nullable T reference, @Nullable String messageTemplate, Object... args) {
161    if (reference == null) {
162      throw new NullPointerException(format(messageTemplate, args));
163    }
164    return reference;
165  }
166
167  /**
168   * Ensures that the current thread is the main thread.
169   *
170   * @throws IllegalStateException if called on a background thread
171   */
172  public static void isMainThread() {
173    isMainThread(null);
174  }
175
176  /**
177   * Ensures that the current thread is the main thread.
178   *
179   * @param messageTemplate the message to log, possible with format arguments.
180   * @param args optional arguments to be used in the formatted string.
181   * @throws IllegalStateException if called on a background thread
182   */
183  public static void isMainThread(@Nullable String messageTemplate, Object... args) {
184    if (!areThreadAssertsEnabled) {
185      return;
186    }
187    checkState(Looper.getMainLooper().equals(Looper.myLooper()), messageTemplate, args);
188  }
189
190  /**
191   * Ensures that the current thread is a worker thread.
192   *
193   * @throws IllegalStateException if called on the main thread
194   */
195  public static void isWorkerThread() {
196    isWorkerThread(null);
197  }
198
199  /**
200   * Ensures that the current thread is a worker thread.
201   *
202   * @param messageTemplate the message to log, possible with format arguments.
203   * @param args optional arguments to be used in the formatted string.
204   * @throws IllegalStateException if called on the main thread
205   */
206  public static void isWorkerThread(@Nullable String messageTemplate, Object... args) {
207    if (!areThreadAssertsEnabled) {
208      return;
209    }
210    checkState(!Looper.getMainLooper().equals(Looper.myLooper()), messageTemplate, args);
211  }
212
213  private static String format(@Nullable String messageTemplate, Object... args) {
214    if (messageTemplate == null) {
215      return null;
216    }
217    return String.format(messageTemplate, args);
218  }
219}
220