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