001 /*
002 * Created on Dec 20, 2010
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 @2010-2011 the original author or authors.
014 */
015 package org.fest.assertions.internal;
016
017 import java.util.Comparator;
018
019 import org.fest.assertions.core.ArraySortedAssert;
020 import org.fest.assertions.core.AssertionInfo;
021 import org.fest.assertions.data.Index;
022 import org.fest.util.ComparisonStrategy;
023 import org.fest.util.StandardComparisonStrategy;
024 import org.fest.util.VisibleForTesting;
025
026 /**
027 * Reusable assertions for arrays of {@code double}s.
028 *
029 * @author Alex Ruiz
030 */
031 public class DoubleArrays {
032
033 private static final DoubleArrays INSTANCE = new DoubleArrays();
034
035 /**
036 * Returns the singleton instance of this class.
037 * @return the singleton instance of this class.
038 */
039 public static DoubleArrays instance() {
040 return INSTANCE;
041 }
042
043 private Arrays arrays = Arrays.instance();
044
045 @VisibleForTesting Failures failures = Failures.instance();
046
047 @VisibleForTesting DoubleArrays() {
048 this(StandardComparisonStrategy.instance());
049 }
050
051 public DoubleArrays(ComparisonStrategy comparisonStrategy) {
052 this.arrays = new Arrays(comparisonStrategy);
053 }
054
055 @VisibleForTesting
056 public Comparator<?> getComparator() {
057 return arrays.getComparator();
058 }
059
060 /**
061 * Asserts that the given array is {@code null} or empty.
062 * @param info contains information about the assertion.
063 * @param actual the given array.
064 * @throws AssertionError if the given array is not {@code null} *and* contains one or more elements.
065 */
066 public void assertNullOrEmpty(AssertionInfo info, double[] actual) {
067 arrays.assertNullOrEmpty(info, failures, actual);
068 }
069
070 /**
071 * Asserts that the given array is empty.
072 * @param info contains information about the assertion.
073 * @param actual the given array.
074 * @throws AssertionError if the given array is {@code null}.
075 * @throws AssertionError if the given array is not empty.
076 */
077 public void assertEmpty(AssertionInfo info, double[] actual) {
078 arrays.assertEmpty(info, failures, actual);
079 }
080
081 /**
082 * Asserts that the given array is not empty.
083 * @param info contains information about the assertion.
084 * @param actual the given array.
085 * @throws AssertionError if the given array is {@code null}.
086 * @throws AssertionError if the given array is empty.
087 */
088 public void assertNotEmpty(AssertionInfo info, double[] actual) {
089 arrays.assertNotEmpty(info, failures, actual);
090 }
091
092 /**
093 * Asserts that the number of elements in the given array is equal to the expected one.
094 * @param info contains information about the assertion.
095 * @param actual the given array.
096 * @param expectedSize the expected size of {@code actual}.
097 * @throws AssertionError if the given array is {@code null}.
098 * @throws AssertionError if the number of elements in the given array is different than the expected one.
099 */
100 public void assertHasSize(AssertionInfo info, double[] actual, int expectedSize) {
101 arrays.assertHasSize(info, failures, actual, expectedSize);
102 }
103
104 /**
105 * Asserts that the given array contains the given values, in any order.
106 * @param info contains information about the assertion.
107 * @param actual the given array.
108 * @param values the values that are expected to be in the given array.
109 * @throws NullPointerException if the array of values is {@code null}.
110 * @throws IllegalArgumentException if the array of values is empty.
111 * @throws AssertionError if the given array is {@code null}.
112 * @throws AssertionError if the given array does not contain the given values.
113 */
114 public void assertContains(AssertionInfo info, double[] actual, double[] values) {
115 arrays.assertContains(info, failures, actual, values);
116 }
117
118 /**
119 * Verifies that the given array contains the given value at the given index.
120 * @param info contains information about the assertion.
121 * @param actual the given array.
122 * @param value the value to look for.
123 * @param index the index where the value should be stored in the given array.
124 * @throws AssertionError if the given array is {@code null} or empty.
125 * @throws NullPointerException if the given {@code Index} is {@code null}.
126 * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of
127 * the given array.
128 * @throws AssertionError if the given array does not contain the given value at the given index.
129 */
130 public void assertContains(AssertionInfo info, double[] actual, double value, Index index) {
131 arrays.assertContains(info, failures, actual, value, index);
132 }
133
134 /**
135 * Verifies that the given array does not contain the given value at the given index.
136 * @param info contains information about the assertion.
137 * @param actual the given array.
138 * @param value the value to look for.
139 * @param index the index where the value should be stored in the given array.
140 * @throws AssertionError if the given array is {@code null}.
141 * @throws NullPointerException if the given {@code Index} is {@code null}.
142 * @throws AssertionError if the given array contains the given value at the given index.
143 */
144 public void assertDoesNotContain(AssertionInfo info, double[] actual, double value, Index index) {
145 arrays.assertDoesNotContain(info, failures, actual, value, index);
146 }
147
148 /**
149 * Asserts that the given array contains only the given values and nothing else, in any order.
150 * @param info contains information about the assertion.
151 * @param actual the given array.
152 * @param values the values that are expected to be in the given array.
153 * @throws NullPointerException if the array of values is {@code null}.
154 * @throws IllegalArgumentException if the array of values is empty.
155 * @throws AssertionError if the given array is {@code null}.
156 * @throws AssertionError if the given array does not contain the given values or if the given
157 * array contains values that are not in the given array.
158 */
159 public void assertContainsOnly(AssertionInfo info, double[] actual, double[] values) {
160 arrays.assertContainsOnly(info, failures, actual, values);
161 }
162
163 /**
164 * Verifies that the given array contains the given sequence of values, without any other values between them.
165 * @param info contains information about the assertion.
166 * @param actual the given array.
167 * @param sequence the sequence of values to look for.
168 * @throws AssertionError if the given array is {@code null}.
169 * @throws NullPointerException if the given sequence is {@code null}.
170 * @throws IllegalArgumentException if the given sequence is empty.
171 * @throws AssertionError if the given array does not contain the given sequence of values.
172 */
173 public void assertContainsSequence(AssertionInfo info, double[] actual, double[] sequence) {
174 arrays.assertContainsSequence(info, failures, actual, sequence);
175 }
176
177 /**
178 * Asserts that the given array does not contain the given values.
179 * @param info contains information about the assertion.
180 * @param actual the given array.
181 * @param values the values that are expected not to be in the given array.
182 * @throws NullPointerException if the array of values is {@code null}.
183 * @throws IllegalArgumentException if the array of values is empty.
184 * @throws AssertionError if the given array is {@code null}.
185 * @throws AssertionError if the given array contains any of given values.
186 */
187 public void assertDoesNotContain(AssertionInfo info, double[] actual, double[] values) {
188 arrays.assertDoesNotContain(info, failures, actual, values);
189 }
190
191 /**
192 * Asserts that the given array does not have duplicate values.
193 * @param info contains information about the assertion.
194 * @param actual the given array.
195 * @throws NullPointerException if the array of values is {@code null}.
196 * @throws IllegalArgumentException if the array of values is empty.
197 * @throws AssertionError if the given array is {@code null}.
198 * @throws AssertionError if the given array contains duplicate values.
199 */
200 public void assertDoesNotHaveDuplicates(AssertionInfo info, double[] actual) {
201 arrays.assertDoesNotHaveDuplicates(info, failures, actual);
202 }
203
204 /**
205 * Verifies that the given array starts with the given sequence of values, without any other values between them.
206 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, double[], double[])}</code>, but it also verifies
207 * that the first element in the sequence is also the first element of the given array.
208 * @param info contains information about the assertion.
209 * @param actual the given array.
210 * @param sequence the sequence of values to look for.
211 * @throws NullPointerException if the given argument is {@code null}.
212 * @throws IllegalArgumentException if the given argument is an empty array.
213 * @throws AssertionError if the given array is {@code null}.
214 * @throws AssertionError if the given array does not start with the given sequence of values.
215 */
216 public void assertStartsWith(AssertionInfo info, double[] actual, double[] sequence) {
217 arrays.assertStartsWith(info, failures, actual, sequence);
218 }
219
220 /**
221 * Verifies that the given array ends with the given sequence of values, without any other values between them.
222 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, double[], double[])}</code>, but it also verifies
223 * that the last element in the sequence is also the last element of the given array.
224 * @param info contains information about the assertion.
225 * @param actual the given array.
226 * @param sequence the sequence of values to look for.
227 * @throws NullPointerException if the given argument is {@code null}.
228 * @throws IllegalArgumentException if the given argument is an empty array.
229 * @throws AssertionError if the given array is {@code null}.
230 * @throws AssertionError if the given array does not end with the given sequence of values.
231 */
232 public void assertEndsWith(AssertionInfo info, double[] actual, double[] sequence) {
233 arrays.assertEndsWith(info, failures, actual, sequence);
234 }
235
236 /**
237 * Concrete implementation of {@link ArraySortedAssert#isSorted()}.
238 *
239 * @param info contains information about the assertion.
240 * @param actual the given array.
241 */
242 public void assertIsSorted(AssertionInfo info, double[] actual) {
243 arrays.assertIsSorted(info, failures, actual);
244 }
245
246 /**
247 * Concrete implementation of {@link ArraySortedAssert#isSortedAccordingTo(Comparator)}.
248 *
249 * @param info contains information about the assertion.
250 * @param actual the given array.
251 * @param comparator the {@link Comparator} used to compare array elements
252 */
253 public void assertIsSortedAccordingToComparator(AssertionInfo info, double[] actual,
254 Comparator<? extends Double> comparator) {
255 Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
256 }
257 }