001 /* 002 * Created on Nov 3, 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.core.Condition; 022 import org.fest.assertions.data.Index; 023 import org.fest.util.ComparisonStrategy; 024 import org.fest.util.StandardComparisonStrategy; 025 import org.fest.util.VisibleForTesting; 026 027 /** 028 * Reusable assertions for arrays of objects. 029 * 030 * @author Alex Ruiz 031 * @author Joel Costigliola 032 * @author Nicolas François 033 */ 034 public class ObjectArrays { 035 036 private static final ObjectArrays INSTANCE = new ObjectArrays(); 037 038 /** 039 * Returns the singleton instance of this class. 040 * @return the singleton instance of this class. 041 */ 042 public static ObjectArrays instance() { 043 return INSTANCE; 044 } 045 046 private Arrays arrays = Arrays.instance(); 047 048 @VisibleForTesting 049 ObjectArrays() { 050 this(StandardComparisonStrategy.instance()); 051 } 052 053 public ObjectArrays(ComparisonStrategy comparisonStrategy) { 054 this.arrays = new Arrays(comparisonStrategy); 055 } 056 057 @VisibleForTesting 058 public Comparator<?> getComparator() { 059 return arrays.getComparator(); 060 } 061 062 @VisibleForTesting 063 Failures failures = Failures.instance(); 064 065 @VisibleForTesting 066 Conditions conditions = Conditions.instance(); 067 068 /** 069 * Asserts that the given array is {@code null} or empty. 070 * @param info contains information about the assertion. 071 * @param actual the given array. 072 * @throws AssertionError if the given array is not {@code null} *and* contains one or more elements. 073 */ 074 public void assertNullOrEmpty(AssertionInfo info, Object[] actual) { 075 arrays.assertNullOrEmpty(info, failures, actual); 076 } 077 078 /** 079 * Asserts that the given array is empty. 080 * @param info contains information about the assertion. 081 * @param actual the given array. 082 * @throws AssertionError if the given array is {@code null}. 083 * @throws AssertionError if the given array is not empty. 084 */ 085 public void assertEmpty(AssertionInfo info, Object[] actual) { 086 arrays.assertEmpty(info, failures, actual); 087 } 088 089 /** 090 * Asserts that the given array is not empty. 091 * @param info contains information about the assertion. 092 * @param actual the given array. 093 * @throws AssertionError if the given array is {@code null}. 094 * @throws AssertionError if the given array is empty. 095 */ 096 public void assertNotEmpty(AssertionInfo info, Object[] actual) { 097 arrays.assertNotEmpty(info, failures, actual); 098 } 099 100 /** 101 * Asserts that the number of elements in the given array is equal to the expected one. 102 * @param info contains information about the assertion. 103 * @param actual the given array. 104 * @param expectedSize the expected size of {@code actual}. 105 * @throws AssertionError if the given array is {@code null}. 106 * @throws AssertionError if the number of elements in the given array is different than the expected one. 107 */ 108 public void assertHasSize(AssertionInfo info, Object[] actual, int expectedSize) { 109 arrays.assertHasSize(info, failures, actual, expectedSize); 110 } 111 112 /** 113 * Asserts that the given array contains the given values, in any order. 114 * @param info contains information about the assertion. 115 * @param actual the given array. 116 * @param values the values that are expected to be in the given array. 117 * @throws NullPointerException if the array of values is {@code null}. 118 * @throws IllegalArgumentException if the array of values is empty. 119 * @throws AssertionError if the given array is {@code null}. 120 * @throws AssertionError if the given array does not contain the given values. 121 */ 122 public void assertContains(AssertionInfo info, Object[] actual, Object[] values) { 123 arrays.assertContains(info, failures, actual, values); 124 } 125 126 /** 127 * Verifies that the given array contains the given object at the given index. 128 * @param info contains information about the assertion. 129 * @param actual the given array. 130 * @param value the object to look for. 131 * @param index the index where the object should be stored in the given array. 132 * @throws AssertionError if the given array is {@code null} or empty. 133 * @throws NullPointerException if the given {@code Index} is {@code null}. 134 * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of 135 * the given array. 136 * @throws AssertionError if the given array does not contain the given object at the given index. 137 */ 138 public void assertContains(AssertionInfo info, Object[] actual, Object value, Index index) { 139 arrays.assertContains(info, failures, actual, value, index); 140 } 141 142 /** 143 * Verifies that the given array does not contain the given object at the given index. 144 * @param info contains information about the assertion. 145 * @param actual the given array. 146 * @param value the object to look for. 147 * @param index the index where the object should be stored in the given array. 148 * @throws AssertionError if the given array is {@code null}. 149 * @throws NullPointerException if the given {@code Index} is {@code null}. 150 * @throws AssertionError if the given array contains the given object at the given index. 151 */ 152 public void assertDoesNotContain(AssertionInfo info, Object[] actual, Object value, Index index) { 153 arrays.assertDoesNotContain(info, failures, actual, value, index); 154 } 155 156 /** 157 * Asserts that the given array contains only the given values and nothing else, in any order. 158 * @param info contains information about the assertion. 159 * @param actual the given array. 160 * @param values the values that are expected to be in the given array. 161 * @throws NullPointerException if the array of values is {@code null}. 162 * @throws IllegalArgumentException if the array of values is empty. 163 * @throws AssertionError if the given array is {@code null}. 164 * @throws AssertionError if the given array does not contain the given values or if the given array contains values 165 * that are not in the given array. 166 */ 167 public void assertContainsOnly(AssertionInfo info, Object[] actual, Object[] values) { 168 arrays.assertContainsOnly(info, failures, actual, values); 169 } 170 171 /** 172 * Verifies that the given array contains the given sequence of objects, without any other objects between them. 173 * @param info contains information about the assertion. 174 * @param actual the given array. 175 * @param sequence the sequence of objects to look for. 176 * @throws AssertionError if the given array is {@code null}. 177 * @throws NullPointerException if the given sequence is {@code null}. 178 * @throws IllegalArgumentException if the given sequence is empty. 179 * @throws AssertionError if the given array does not contain the given sequence of objects. 180 */ 181 public void assertContainsSequence(AssertionInfo info, Object[] actual, Object[] sequence) { 182 arrays.assertContainsSequence(info, failures, actual, sequence); 183 } 184 185 /** 186 * Asserts that the given array does not contain the given values. 187 * @param info contains information about the assertion. 188 * @param actual the given array. 189 * @param values the values that are expected not to be in the given array. 190 * @throws NullPointerException if the array of values is {@code null}. 191 * @throws IllegalArgumentException if the array of values is empty. 192 * @throws AssertionError if the given array is {@code null}. 193 * @throws AssertionError if the given array contains any of given values. 194 */ 195 public void assertDoesNotContain(AssertionInfo info, Object[] actual, Object[] values) { 196 arrays.assertDoesNotContain(info, failures, actual, values); 197 } 198 199 /** 200 * Asserts that the given array does not have duplicate values. 201 * @param info contains information about the assertion. 202 * @param actual the given array. 203 * @throws NullPointerException if the array of values is {@code null}. 204 * @throws IllegalArgumentException if the array of values is empty. 205 * @throws AssertionError if the given array is {@code null}. 206 * @throws AssertionError if the given array contains duplicate values. 207 */ 208 public void assertDoesNotHaveDuplicates(AssertionInfo info, Object[] actual) { 209 arrays.assertDoesNotHaveDuplicates(info, failures, actual); 210 } 211 212 /** 213 * Verifies that the given array starts with the given sequence of objects, without any other objects between them. 214 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, Object[], Object[])}</code>, but it also verifies 215 * that the first element in the sequence is also the first element of the given array. 216 * @param info contains information about the assertion. 217 * @param actual the given array. 218 * @param sequence the sequence of objects to look for. 219 * @throws NullPointerException if the given argument is {@code null}. 220 * @throws IllegalArgumentException if the given argument is an empty array. 221 * @throws AssertionError if the given array is {@code null}. 222 * @throws AssertionError if the given array does not start with the given sequence of objects. 223 */ 224 public void assertStartsWith(AssertionInfo info, Object[] actual, Object[] sequence) { 225 arrays.assertStartsWith(info, failures, actual, sequence); 226 } 227 228 /** 229 * Verifies that the given array ends with the given sequence of objects, without any other objects between them. 230 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, Object[], Object[])}</code>, but it also verifies 231 * that the last element in the sequence is also the last element of the given array. 232 * @param info contains information about the assertion. 233 * @param actual the given array. 234 * @param sequence the sequence of objects to look for. 235 * @throws NullPointerException if the given argument is {@code null}. 236 * @throws IllegalArgumentException if the given argument is an empty array. 237 * @throws AssertionError if the given array is {@code null}. 238 * @throws AssertionError if the given array does not end with the given sequence of objects. 239 */ 240 public void assertEndsWith(AssertionInfo info, Object[] actual, Object[] sequence) { 241 arrays.assertEndsWith(info, failures, actual, sequence); 242 } 243 244 /** 245 * Asserts that the given array contains at least a null element. 246 * @param info contains information about the assertion. 247 * @param actual the given array. 248 * @throws AssertionError if the given array is {@code null}. 249 * @throws AssertionError if the given array does not contain a null element. 250 */ 251 public void assertContainsNull(AssertionInfo info, Object[] actual) { 252 arrays.assertContainsNull(info, failures, actual); 253 } 254 255 /** 256 * Asserts that the given array does not contain null elements. 257 * @param info contains information about the assertion. 258 * @param actual the given array. 259 * @throws AssertionError if the given array is {@code null}. 260 * @throws AssertionError if the given array contains a null element. 261 */ 262 public void assertDoesNotContainNull(AssertionInfo info, Object[] actual) { 263 arrays.assertDoesNotContainNull(info, failures, actual); 264 } 265 266 /** 267 * Assert that each element of given array satisfies the given condition. 268 * @param info contains information about the assertion. 269 * @param actual the given array. 270 * @param condition the given {@code Condition}. 271 * @throws NullPointerException if the given condition is {@code null}. 272 * @throws AssertionError if a element cannot be cast to E. 273 * @throws AssertionError if one or more element not satisfy the given condition. 274 */ 275 public <E> void assertAre(AssertionInfo info, Object[] actual, Condition<E> condition) { 276 arrays.assertAre(info, failures, conditions, actual, condition); 277 } 278 279 /** 280 * Assert that each element of given array not satisfies the given condition. 281 * @param info contains information about the assertion. 282 * @param actual the given array. 283 * @param condition the given {@code Condition}. 284 * @throws NullPointerException if the given condition is {@code null}. 285 * @throws AssertionError if a element cannot be cast to E. 286 * @throws AssertionError if one or more element satisfy the given condition. 287 */ 288 public <E> void assertAreNot(AssertionInfo info, Object[] actual, Condition<E> condition) { 289 arrays.assertAreNot(info, failures, conditions, actual, condition); 290 } 291 292 /** 293 * Assert that each element of given array satisfies the given condition. 294 * @param info contains information about the assertion. 295 * @param actual the given array. 296 * @param condition the given {@code Condition}. 297 * @throws NullPointerException if the given condition is {@code null}. 298 * @throws AssertionError if a element cannot be cast to E. 299 * @throws AssertionError if one or more element not satisfy the given condition. 300 */ 301 public <E> void assertHave(AssertionInfo info, Object[] actual, Condition<E> condition) { 302 arrays.assertHave(info, failures, conditions, actual, condition); 303 } 304 305 /** 306 * Assert that each element of given array not satisfies the given condition. 307 * @param info contains information about the assertion. 308 * @param actual the given array. 309 * @param condition the given {@code Condition}. 310 * @throws NullPointerException if the given condition is {@code null}. 311 * @throws AssertionError if a element cannot be cast to E. 312 * @throws AssertionError if one or more element satisfy the given condition. 313 */ 314 public <E> void assertDoNotHave(AssertionInfo info, Object[] actual, Condition<E> condition) { 315 arrays.assertHaveNot(info, failures, conditions, actual, condition); 316 } 317 318 /** 319 * Assert that there is <b>at least</b> <i>n</i> array elements satisfying the given condition. 320 * @param info contains information about the assertion. 321 * @param actual the given array. 322 * @param n the minimum number of times the condition should be verified. 323 * @param condition the given {@code Condition}. 324 * @throws NullPointerException if the given condition is {@code null}. 325 * @throws AssertionError if a element cannot be cast to E. 326 * @throws AssertionError if the number of elements satisfying the given condition is < n. 327 */ 328 public <E> void assertAreAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 329 arrays.assertAreAtLeast(info, failures, conditions, actual, n, condition); 330 } 331 332 /** 333 * Assert that there is <b>at least</b> <i>n</i> array elements <b>not</b> satisfying the given condition. 334 * @param info contains information about the assertion. 335 * @param actual the given array. 336 * @param n the number of times the condition should not be verified at least. 337 * @param condition the given {@code Condition}. 338 * @throws NullPointerException if the given condition is {@code null}. 339 * @throws AssertionError if a element cannot be cast to E. 340 * @throws AssertionError if the number of elements not satisfying the given condition is < n. 341 */ 342 public <E> void assertAreNotAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 343 arrays.assertAreNotAtLeast(info, failures, conditions, actual, n, condition); 344 } 345 346 /** 347 * Assert that there is <b>at most</b> <i>n</i> array elements satisfying the given condition. 348 * @param info contains information about the assertion. 349 * @param actual the given array. 350 * @param n the number of times the condition should be at most verified. 351 * @param condition the given {@code Condition}. 352 * @throws NullPointerException if the given condition is {@code null}. 353 * @throws AssertionError if a element cannot be cast to E. 354 * @throws AssertionError if the number of elements satisfying the given condition is > n. 355 */ 356 public <E> void assertAreAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 357 arrays.assertAreAtMost(info, failures, conditions, actual, n, condition); 358 } 359 360 /** 361 * Verifies that there is <b>at most</b> <i>n</i> array elements <b>not</b> satisfying the given condition. 362 * @param info contains information about the assertion. 363 * @param actual the given array. 364 * @param n the number of times the condition should not be verified at most. 365 * @param condition the given {@code Condition}. 366 * @throws NullPointerException if the given condition is {@code null}. 367 * @throws AssertionError if a element cannot be cast to E. 368 * @throws AssertionError if the number of elements not satisfying the given condition is > n. 369 */ 370 public <E> void assertAreNotAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 371 arrays.assertAreNotAtMost(info, failures, conditions, actual, n, condition); 372 } 373 374 /** 375 * Verifies that there is <b>exactly</b> <i>n</i> array elements satisfying the given condition. 376 * @param info contains information about the assertion. 377 * @param actual the given array. 378 * @param n the exact number of times the condition should be verified. 379 * @param condition the given {@code Condition}. 380 * @throws NullPointerException if the given condition is {@code null}. 381 * @throws AssertionError if a element cannot be cast to E. 382 * @throws AssertionError if the number of elements satisfying the given condition is ≠ n. 383 */ 384 public <E> void assertAreExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 385 arrays.assertAreExactly(info, failures, conditions, actual, n, condition); 386 } 387 388 /** 389 * Verifies that there is <b>exactly</b> <i>n</i> elements in the actual {@code Iterable} <b>not</b> satisfying the 390 * given condition. 391 * @param info contains information about the assertion. 392 * @param actual the given array. 393 * @param n most times the condition should not be verify. 394 * @param condition the given {@code Condition}. 395 * @throws NullPointerException if the given condition is {@code null}. 396 * @throws AssertionError if a element cannot be cast to E. 397 * @throws AssertionError if the number of elements not satisfying the given condition is ≠ n. 398 */ 399 public <E> void assertAreNotExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 400 arrays.assertAreNotExactly(info, failures, conditions, actual, n, condition); 401 } 402 403 /** 404 * An alias method of {@link #assertAreAtLeast(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 405 * (same logic, only error message differs). 406 */ 407 public <E> void assertHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 408 arrays.assertHaveAtLeast(info, failures, conditions, actual, times, condition); 409 } 410 411 /** 412 * An alias method of {@link #assertAreNotAtLeast(AssertionInfo, Object[], int, Condition)} to provide a richer fluent 413 * api (same logic, only error message differs). 414 */ 415 public <E> void assertDoNotHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 416 arrays.assertDoNotHaveAtLeast(info, failures, conditions, actual, times, condition); 417 } 418 419 /** 420 * An alias method of {@link #assertAreAtMost(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 421 * (same logic, only error message differs). 422 */ 423 public <E> void assertHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 424 arrays.assertHaveAtMost(info, failures, conditions, actual, times, condition); 425 } 426 427 /** 428 * An alias method of {@link #assertAreNotAtMost(AssertionInfo, Object[], int, Condition)} to provide a richer fluent 429 * api (same logic, only error message differs). 430 */ 431 public <E> void assertDoNotHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 432 arrays.assertDoNotHaveAtMost(info, failures, conditions, actual, times, condition); 433 } 434 435 /** 436 * An alias method of {@link #assertAreExactly(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 437 * (same logic, only error message differs). 438 */ 439 public <E> void assertHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 440 arrays.assertHaveExactly(info, failures, conditions, actual, times, condition); 441 } 442 443 /** 444 * An alias method of {@link #assertAreNotExactly(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 445 * (same logic, only error message differs). 446 */ 447 public <E> void assertDoNotHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 448 arrays.assertDoNotHaveExactly(info, failures, conditions, actual, times, condition); 449 } 450 451 /** 452 * Concrete implementation of {@link ArraySortedAssert#isSorted()}. 453 * 454 * @param info contains information about the assertion. 455 * @param actual the given array. 456 */ 457 public void assertIsSorted(AssertionInfo info, Object[] actual) { 458 arrays.assertIsSorted(info, failures, actual); 459 } 460 461 /** 462 * Concrete implementation of {@link ArraySortedAssert#isSortedAccordingTo(Comparator)}. 463 * 464 * @param info contains information about the assertion. 465 * @param actual the given array. 466 * @param comparator the {@link Comparator} used to compare array elements 467 */ 468 public void assertIsSortedAccordingToComparator(AssertionInfo info, Object[] actual, 469 Comparator<? extends Object> comparator) { 470 Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator); 471 } 472 }