001 /*
002 * Created on Feb 14, 2008
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except
005 * in compliance with the License. You may obtain a copy of the License at
006 *
007 * http://www.apache.org/licenses/LICENSE-2.0
008 *
009 * Unless required by applicable law or agreed to in writing, software distributed under the License
010 * is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
011 * or implied. See the License for the specific language governing permissions and limitations under
012 * the License.
013 *
014 * Copyright @2008-2009 the original author or authors.
015 */
016 package org.fest.assertions;
017
018 import static org.fest.assertions.ArrayInspection.copy;
019 import static org.fest.assertions.ErrorMessages.unexpectedEqual;
020 import static org.fest.assertions.ErrorMessages.unexpectedNotEqual;
021
022 import java.util.Arrays;
023
024 /**
025 * Understands assertion methods for <code>float</code> arrays. To create a new instance of this class use the
026 * method <code>{@link Assertions#assertThat(float[])}</code>.
027 *
028 * @author Yvonne Wang
029 * @author Alex Ruiz
030 */
031 public class FloatArrayAssert extends ArrayAssert<float[]> {
032
033 /**
034 * Creates a new </code>{@link FloatArrayAssert}</code>.
035 * @param actual the target to verify.
036 */
037 protected FloatArrayAssert(float... actual) {
038 super(actual);
039 }
040
041 /** {@inheritDoc} */
042 public FloatArrayAssert as(String description) {
043 description(description);
044 return this;
045 }
046
047 /** {@inheritDoc} */
048 public FloatArrayAssert describedAs(String description) {
049 return as(description);
050 }
051
052 /** {@inheritDoc} */
053 public FloatArrayAssert as(Description description) {
054 description(description);
055 return this;
056 }
057
058 /** {@inheritDoc} */
059 public FloatArrayAssert describedAs(Description description) {
060 return as(description);
061 }
062
063 /**
064 * Verifies that the actual <code>float</code> array contains the given values.
065 * @param values the values to look for.
066 * @return this assertion object.
067 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
068 * @throws NullPointerException if the given <code>float</code> array is <code>null</code>.
069 * @throws AssertionError if the actual <code>float</code> array does not contain the given values.
070 */
071 public FloatArrayAssert contains(float...values) {
072 isNotNull();
073 validateIsNotNull(values);
074 assertContains(copy(values));
075 return this;
076 }
077
078 /**
079 * Verifies that the actual <code>float</code> array contains the given values <strong>only</strong>.
080 * @param values the values to look for.
081 * @return this assertion object.
082 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
083 * @throws NullPointerException if the given <code>float</code> array is <code>null</code>.
084 * @throws AssertionError if the actual <code>float</code> array does not contain the given objects, or if the actual
085 * <code>float</code> array contains elements other than the ones specified.
086 */
087 public FloatArrayAssert containsOnly(float...values) {
088 isNotNull();
089 validateIsNotNull(values);
090 assertContainsOnly(copy(values));
091 return this;
092 }
093
094 /**
095 * Verifies that the actual <code>float</code> array does not contain the given values.
096 * @param values the values the array should exclude.
097 * @return this assertion object.
098 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
099 * @throws NullPointerException if the given <code>float</code> array is <code>null</code>.
100 * @throws AssertionError if the actual <code>Object</code> array contains any of the given values.
101 */
102 public FloatArrayAssert excludes(float...values) {
103 isNotNull();
104 validateIsNotNull(values);
105 assertExcludes(copy(values));
106 return this;
107 }
108
109 private void validateIsNotNull(float[] values) {
110 if (values == null)
111 throw new NullPointerException(formattedErrorMessage("the given array of floats should not be null"));
112 }
113
114 /**
115 * Verifies that the actual <code>float</code> array satisfies the given condition.
116 * @param condition the given condition.
117 * @return this assertion object.
118 * @throws NullPointerException if the given condition is <code>null</code>.
119 * @throws AssertionError if the actual <code>float</code> array does not satisfy the given condition.
120 * @see #is(Condition)
121 */
122 public FloatArrayAssert satisfies(Condition<float[]> condition) {
123 assertSatisfies(condition);
124 return this;
125 }
126
127 /**
128 * Verifies that the actual <code>float</code> array does not satisfy the given condition.
129 * @param condition the given condition.
130 * @return this assertion object.
131 * @throws NullPointerException if the given condition is <code>null</code>.
132 * @throws AssertionError if the actual <code>float</code> array satisfies the given condition.
133 * @see #isNot(Condition)
134 */
135 public FloatArrayAssert doesNotSatisfy(Condition<float[]> condition) {
136 assertDoesNotSatisfy(condition);
137 return this;
138 }
139
140
141 /**
142 * Alias for <code>{@link #satisfies(Condition)}</code>.
143 * @param condition the given condition.
144 * @return this assertion object.
145 * @throws NullPointerException if the given condition is <code>null</code>.
146 * @throws AssertionError if the actual <code>float</code> array does not satisfy the given condition.
147 * @since 1.2
148 */
149 public FloatArrayAssert is(Condition<float[]> condition) {
150 assertIs(condition);
151 return this;
152 }
153
154 /**
155 * Alias for <code>{@link #doesNotSatisfy(Condition)}</code>.
156 * @param condition the given condition.
157 * @return this assertion object.
158 * @throws NullPointerException if the given condition is <code>null</code>.
159 * @throws AssertionError if the actual <code>float</code> array satisfies the given condition.
160 * @since 1.2
161 */
162 public FloatArrayAssert isNot(Condition<float[]> condition) {
163 assertIsNot(condition);
164 return this;
165 }
166
167 /**
168 * Verifies that the actual <code>float</code> array is not <code>null</code>.
169 * @return this assertion object.
170 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
171 */
172 public FloatArrayAssert isNotNull() {
173 assertThatActualIsNotNull();
174 return this;
175 }
176
177 /**
178 * Verifies that the actual <code>float</code> array contains at least on element.
179 * @return this assertion object.
180 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
181 * @throws AssertionError if the actual <code>float</code> array is empty.
182 */
183 public FloatArrayAssert isNotEmpty() {
184 assertThatActualIsNotEmpty();
185 return this;
186 }
187
188 /**
189 * Verifies that the actual <code>float</code> array is equal to the given array. Array equality is checked by
190 * <code>{@link Arrays#equals(float[], float[])}</code>.
191 * @param expected the given array to compare the actual array to.
192 * @return this assertion object.
193 * @throws AssertionError if the actual <code>float</code> array is not equal to the given one.
194 */
195 public FloatArrayAssert isEqualTo(float[] expected) {
196 if (Arrays.equals(actual, expected)) return this;
197 failIfCustomMessageIsSet();
198 throw failure(unexpectedNotEqual(actual, expected));
199 }
200
201 /**
202 * Verifies that the actual <code>float</code> array is not equal to the given array. Array equality is checked by
203 * <code>{@link Arrays#equals(float[], float[])}</code>.
204 * @param array the given array to compare the actual array to.
205 * @return this assertion object.
206 * @throws AssertionError if the actual <code>float</code> array is equal to the given one.
207 */
208 public FloatArrayAssert isNotEqualTo(float[] array) {
209 if (!Arrays.equals(actual, array)) return this;
210 failIfCustomMessageIsSet();
211 throw failure(unexpectedEqual(actual, array));
212 }
213
214 /**
215 * Verifies that the number of elements in the actual <code>float</code> array is equal to the given one.
216 * @param expected the expected number of elements in the actual <code>float</code> array.
217 * @return this assertion object.
218 * @throws AssertionError if the actual <code>float</code> array is <code>null</code>.
219 * @throws AssertionError if the number of elements in the actual <code>float</code> array is not equal to the given
220 * one.
221 */
222 public FloatArrayAssert hasSize(int expected) {
223 assertThatActualHasSize(expected);
224 return this;
225 }
226
227 /**
228 * Verifies that the actual <code>float</code> array is the same as the given array.
229 * @param expected the given array to compare the actual array to.
230 * @return this assertion object.
231 * @throws AssertionError if the actual <code>float</code> array is not the same as the given one.
232 */
233 public FloatArrayAssert isSameAs(float[] expected) {
234 assertSameAs(expected);
235 return this;
236 }
237
238 /**
239 * Verifies that the actual <code>float</code> array is not the same as the given array.
240 * @param expected the given array to compare the actual array to.
241 * @return this assertion object.
242 * @throws AssertionError if the actual <code>float</code> array is the same as the given one.
243 */
244 public FloatArrayAssert isNotSameAs(float[] expected) {
245 assertNotSameAs(expected);
246 return this;
247 }
248
249 /** {@inheritDoc} */
250 public FloatArrayAssert overridingErrorMessage(String message) {
251 replaceDefaultErrorMessagesWith(message);
252 return this;
253 }
254 }