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 * Assert that the actual array has the same size as the other {@code Iterable}. 114 * @param info contains information about the assertion. 115 * @param actual the given iterable. 116 * @param other the group to compare 117 * @throws AssertionError if the actual group is {@code null}. 118 * @throws AssertionError if the other group is {@code null}. 119 * @throws AssertionError if the actual group does not have the same size. 120 */ 121 public void assertHasSameSizeAs(AssertionInfo info, Object[] actual, Iterable<?> other) { 122 arrays.assertHasSameSizeAs(info, failures, actual, other); 123 } 124 125 /** 126 * Assert that the actual array has the same size as the other array. 127 * @param info contains information about the assertion. 128 * @param actual the given array. 129 * @param other the group to compare 130 * @throws AssertionError if the actual group is {@code null}. 131 * @throws AssertionError if the other group is {@code null}. 132 * @throws AssertionError if the actual group does not have the same size. 133 */ 134 public void assertHasSameSizeAs(AssertionInfo info, Object[] actual, Object[] other) { 135 arrays.assertHasSameSizeAs(info, failures, actual, other); 136 } 137 138 /** 139 * Asserts that the given array contains the given values, in any order. 140 * @param info contains information about the assertion. 141 * @param actual the given array. 142 * @param values the values that are expected to be in the given array. 143 * @throws NullPointerException if the array of values is {@code null}. 144 * @throws IllegalArgumentException if the array of values is empty. 145 * @throws AssertionError if the given array is {@code null}. 146 * @throws AssertionError if the given array does not contain the given values. 147 */ 148 public void assertContains(AssertionInfo info, Object[] actual, Object[] values) { 149 arrays.assertContains(info, failures, actual, values); 150 } 151 152 /** 153 * Verifies that the given array contains the given object at the given index. 154 * @param info contains information about the assertion. 155 * @param actual the given array. 156 * @param value the object to look for. 157 * @param index the index where the object should be stored in the given array. 158 * @throws AssertionError if the given array is {@code null} or empty. 159 * @throws NullPointerException if the given {@code Index} is {@code null}. 160 * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of 161 * the given array. 162 * @throws AssertionError if the given array does not contain the given object at the given index. 163 */ 164 public void assertContains(AssertionInfo info, Object[] actual, Object value, Index index) { 165 arrays.assertContains(info, failures, actual, value, index); 166 } 167 168 /** 169 * Verifies that the given array does not contain the given object at the given index. 170 * @param info contains information about the assertion. 171 * @param actual the given array. 172 * @param value the object to look for. 173 * @param index the index where the object should be stored in the given array. 174 * @throws AssertionError if the given array is {@code null}. 175 * @throws NullPointerException if the given {@code Index} is {@code null}. 176 * @throws AssertionError if the given array contains the given object at the given index. 177 */ 178 public void assertDoesNotContain(AssertionInfo info, Object[] actual, Object value, Index index) { 179 arrays.assertDoesNotContain(info, failures, actual, value, index); 180 } 181 182 /** 183 * Asserts that the given array contains only the given values and nothing else, in any order. 184 * @param info contains information about the assertion. 185 * @param actual the given array. 186 * @param values the values that are expected to be in the given array. 187 * @throws NullPointerException if the array of values is {@code null}. 188 * @throws IllegalArgumentException if the array of values is empty. 189 * @throws AssertionError if the given array is {@code null}. 190 * @throws AssertionError if the given array does not contain the given values or if the given array contains values 191 * that are not in the given array. 192 */ 193 public void assertContainsOnly(AssertionInfo info, Object[] actual, Object[] values) { 194 arrays.assertContainsOnly(info, failures, actual, values); 195 } 196 197 /** 198 * Verifies that the given array contains the given sequence of objects, without any other objects between them. 199 * @param info contains information about the assertion. 200 * @param actual the given array. 201 * @param sequence the sequence of objects to look for. 202 * @throws AssertionError if the given array is {@code null}. 203 * @throws NullPointerException if the given sequence is {@code null}. 204 * @throws IllegalArgumentException if the given sequence is empty. 205 * @throws AssertionError if the given array does not contain the given sequence of objects. 206 */ 207 public void assertContainsSequence(AssertionInfo info, Object[] actual, Object[] sequence) { 208 arrays.assertContainsSequence(info, failures, actual, sequence); 209 } 210 211 /** 212 * Asserts that the given array does not contain the given values. 213 * @param info contains information about the assertion. 214 * @param actual the given array. 215 * @param values the values that are expected not to be in the given array. 216 * @throws NullPointerException if the array of values is {@code null}. 217 * @throws IllegalArgumentException if the array of values is empty. 218 * @throws AssertionError if the given array is {@code null}. 219 * @throws AssertionError if the given array contains any of given values. 220 */ 221 public void assertDoesNotContain(AssertionInfo info, Object[] actual, Object[] values) { 222 arrays.assertDoesNotContain(info, failures, actual, values); 223 } 224 225 /** 226 * Asserts that the given array does not have duplicate values. 227 * @param info contains information about the assertion. 228 * @param actual the given array. 229 * @throws NullPointerException if the array of values is {@code null}. 230 * @throws IllegalArgumentException if the array of values is empty. 231 * @throws AssertionError if the given array is {@code null}. 232 * @throws AssertionError if the given array contains duplicate values. 233 */ 234 public void assertDoesNotHaveDuplicates(AssertionInfo info, Object[] actual) { 235 arrays.assertDoesNotHaveDuplicates(info, failures, actual); 236 } 237 238 /** 239 * Verifies that the given array starts with the given sequence of objects, without any other objects between them. 240 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, Object[], Object[])}</code>, but it also verifies 241 * that the first element in the sequence is also the first element of the given array. 242 * @param info contains information about the assertion. 243 * @param actual the given array. 244 * @param sequence the sequence of objects to look for. 245 * @throws NullPointerException if the given argument is {@code null}. 246 * @throws IllegalArgumentException if the given argument is an empty array. 247 * @throws AssertionError if the given array is {@code null}. 248 * @throws AssertionError if the given array does not start with the given sequence of objects. 249 */ 250 public void assertStartsWith(AssertionInfo info, Object[] actual, Object[] sequence) { 251 arrays.assertStartsWith(info, failures, actual, sequence); 252 } 253 254 /** 255 * Verifies that the given array ends with the given sequence of objects, without any other objects between them. 256 * Similar to <code>{@link #assertContainsSequence(AssertionInfo, Object[], Object[])}</code>, but it also verifies 257 * that the last element in the sequence is also the last element of the given array. 258 * @param info contains information about the assertion. 259 * @param actual the given array. 260 * @param sequence the sequence of objects to look for. 261 * @throws NullPointerException if the given argument is {@code null}. 262 * @throws IllegalArgumentException if the given argument is an empty array. 263 * @throws AssertionError if the given array is {@code null}. 264 * @throws AssertionError if the given array does not end with the given sequence of objects. 265 */ 266 public void assertEndsWith(AssertionInfo info, Object[] actual, Object[] sequence) { 267 arrays.assertEndsWith(info, failures, actual, sequence); 268 } 269 270 /** 271 * Asserts that the given array contains at least a null element. 272 * @param info contains information about the assertion. 273 * @param actual the given array. 274 * @throws AssertionError if the given array is {@code null}. 275 * @throws AssertionError if the given array does not contain a null element. 276 */ 277 public void assertContainsNull(AssertionInfo info, Object[] actual) { 278 arrays.assertContainsNull(info, failures, actual); 279 } 280 281 /** 282 * Asserts that the given array does not contain null elements. 283 * @param info contains information about the assertion. 284 * @param actual the given array. 285 * @throws AssertionError if the given array is {@code null}. 286 * @throws AssertionError if the given array contains a null element. 287 */ 288 public void assertDoesNotContainNull(AssertionInfo info, Object[] actual) { 289 arrays.assertDoesNotContainNull(info, failures, actual); 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 assertAre(AssertionInfo info, Object[] actual, Condition<E> condition) { 302 arrays.assertAre(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 assertAreNot(AssertionInfo info, Object[] actual, Condition<E> condition) { 315 arrays.assertAreNot(info, failures, conditions, actual, condition); 316 } 317 318 /** 319 * Assert that each element of given array satisfies the given condition. 320 * @param info contains information about the assertion. 321 * @param actual the given array. 322 * @param condition the given {@code Condition}. 323 * @throws NullPointerException if the given condition is {@code null}. 324 * @throws AssertionError if a element cannot be cast to E. 325 * @throws AssertionError if one or more element not satisfy the given condition. 326 */ 327 public <E> void assertHave(AssertionInfo info, Object[] actual, Condition<E> condition) { 328 arrays.assertHave(info, failures, conditions, actual, condition); 329 } 330 331 /** 332 * Assert that each element of given array not satisfies the given condition. 333 * @param info contains information about the assertion. 334 * @param actual the given array. 335 * @param condition the given {@code Condition}. 336 * @throws NullPointerException if the given condition is {@code null}. 337 * @throws AssertionError if a element cannot be cast to E. 338 * @throws AssertionError if one or more element satisfy the given condition. 339 */ 340 public <E> void assertDoNotHave(AssertionInfo info, Object[] actual, Condition<E> condition) { 341 arrays.assertHaveNot(info, failures, conditions, actual, condition); 342 } 343 344 /** 345 * Assert that there is <b>at least</b> <i>n</i> array elements satisfying the given condition. 346 * @param info contains information about the assertion. 347 * @param actual the given array. 348 * @param n the minimum number of times the condition should be verified. 349 * @param condition the given {@code Condition}. 350 * @throws NullPointerException if the given condition is {@code null}. 351 * @throws AssertionError if a element cannot be cast to E. 352 * @throws AssertionError if the number of elements satisfying the given condition is < n. 353 */ 354 public <E> void assertAreAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 355 arrays.assertAreAtLeast(info, failures, conditions, actual, n, condition); 356 } 357 358 /** 359 * Assert that there is <b>at least</b> <i>n</i> array elements <b>not</b> satisfying the given condition. 360 * @param info contains information about the assertion. 361 * @param actual the given array. 362 * @param n the number of times the condition should not be verified at least. 363 * @param condition the given {@code Condition}. 364 * @throws NullPointerException if the given condition is {@code null}. 365 * @throws AssertionError if a element cannot be cast to E. 366 * @throws AssertionError if the number of elements not satisfying the given condition is < n. 367 */ 368 public <E> void assertAreNotAtLeast(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 369 arrays.assertAreNotAtLeast(info, failures, conditions, actual, n, condition); 370 } 371 372 /** 373 * Assert that there is <b>at most</b> <i>n</i> array elements satisfying the given condition. 374 * @param info contains information about the assertion. 375 * @param actual the given array. 376 * @param n the number of times the condition should be at most verified. 377 * @param condition the given {@code Condition}. 378 * @throws NullPointerException if the given condition is {@code null}. 379 * @throws AssertionError if a element cannot be cast to E. 380 * @throws AssertionError if the number of elements satisfying the given condition is > n. 381 */ 382 public <E> void assertAreAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 383 arrays.assertAreAtMost(info, failures, conditions, actual, n, condition); 384 } 385 386 /** 387 * Verifies that there is <b>at most</b> <i>n</i> array elements <b>not</b> satisfying the given condition. 388 * @param info contains information about the assertion. 389 * @param actual the given array. 390 * @param n the number of times the condition should not be verified at most. 391 * @param condition the given {@code Condition}. 392 * @throws NullPointerException if the given condition is {@code null}. 393 * @throws AssertionError if a element cannot be cast to E. 394 * @throws AssertionError if the number of elements not satisfying the given condition is > n. 395 */ 396 public <E> void assertAreNotAtMost(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 397 arrays.assertAreNotAtMost(info, failures, conditions, actual, n, condition); 398 } 399 400 /** 401 * Verifies that there is <b>exactly</b> <i>n</i> array elements satisfying the given condition. 402 * @param info contains information about the assertion. 403 * @param actual the given array. 404 * @param n the exact number of times the condition should be verified. 405 * @param condition the given {@code Condition}. 406 * @throws NullPointerException if the given condition is {@code null}. 407 * @throws AssertionError if a element cannot be cast to E. 408 * @throws AssertionError if the number of elements satisfying the given condition is ≠ n. 409 */ 410 public <E> void assertAreExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 411 arrays.assertAreExactly(info, failures, conditions, actual, n, condition); 412 } 413 414 /** 415 * Verifies that there is <b>exactly</b> <i>n</i> elements in the actual {@code Iterable} <b>not</b> satisfying the 416 * given condition. 417 * @param info contains information about the assertion. 418 * @param actual the given array. 419 * @param n most times the condition should not be verify. 420 * @param condition the given {@code Condition}. 421 * @throws NullPointerException if the given condition is {@code null}. 422 * @throws AssertionError if a element cannot be cast to E. 423 * @throws AssertionError if the number of elements not satisfying the given condition is ≠ n. 424 */ 425 public <E> void assertAreNotExactly(AssertionInfo info, Object[] actual, int n, Condition<E> condition) { 426 arrays.assertAreNotExactly(info, failures, conditions, actual, n, condition); 427 } 428 429 /** 430 * An alias method of {@link #assertAreAtLeast(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 431 * (same logic, only error message differs). 432 */ 433 public <E> void assertHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 434 arrays.assertHaveAtLeast(info, failures, conditions, actual, times, condition); 435 } 436 437 /** 438 * An alias method of {@link #assertAreNotAtLeast(AssertionInfo, Object[], int, Condition)} to provide a richer fluent 439 * api (same logic, only error message differs). 440 */ 441 public <E> void assertDoNotHaveAtLeast(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 442 arrays.assertDoNotHaveAtLeast(info, failures, conditions, actual, times, condition); 443 } 444 445 /** 446 * An alias method of {@link #assertAreAtMost(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 447 * (same logic, only error message differs). 448 */ 449 public <E> void assertHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 450 arrays.assertHaveAtMost(info, failures, conditions, actual, times, condition); 451 } 452 453 /** 454 * An alias method of {@link #assertAreNotAtMost(AssertionInfo, Object[], int, Condition)} to provide a richer fluent 455 * api (same logic, only error message differs). 456 */ 457 public <E> void assertDoNotHaveAtMost(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 458 arrays.assertDoNotHaveAtMost(info, failures, conditions, actual, times, condition); 459 } 460 461 /** 462 * An alias method of {@link #assertAreExactly(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 463 * (same logic, only error message differs). 464 */ 465 public <E> void assertHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 466 arrays.assertHaveExactly(info, failures, conditions, actual, times, condition); 467 } 468 469 /** 470 * An alias method of {@link #assertAreNotExactly(AssertionInfo, Object[], int, Condition)} to provide a richer fluent api 471 * (same logic, only error message differs). 472 */ 473 public <E> void assertDoNotHaveExactly(AssertionInfo info, Object[] actual, int times, Condition<E> condition) { 474 arrays.assertDoNotHaveExactly(info, failures, conditions, actual, times, condition); 475 } 476 477 /** 478 * Concrete implementation of {@link ArraySortedAssert#isSorted()}. 479 * 480 * @param info contains information about the assertion. 481 * @param actual the given array. 482 */ 483 public void assertIsSorted(AssertionInfo info, Object[] actual) { 484 arrays.assertIsSorted(info, failures, actual); 485 } 486 487 /** 488 * Concrete implementation of {@link ArraySortedAssert#isSortedAccordingTo(Comparator)}. 489 * 490 * @param info contains information about the assertion. 491 * @param actual the given array. 492 * @param comparator the {@link Comparator} used to compare array elements 493 */ 494 public void assertIsSortedAccordingToComparator(AssertionInfo info, Object[] actual, 495 Comparator<? extends Object> comparator) { 496 Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator); 497 } 498 499 }