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