001 /*
002 * Created on Oct 26, 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.api;
016
017 import java.util.Comparator;
018 import java.util.List;
019
020 import org.fest.assertions.core.IndexedObjectEnumerableAssert;
021 import org.fest.assertions.data.Index;
022 import org.fest.assertions.internal.Lists;
023 import org.fest.util.ComparatorBasedComparisonStrategy;
024 import org.fest.util.VisibleForTesting;
025
026 /**
027 * Assertion methods for <code>{@link List}</code>s.
028 * <p>
029 * To create an instance of this class, invoke <code>{@link Assertions#assertThat(List)}</code>.
030 * </p>
031 *
032 * @author Yvonne Wang
033 * @author Alex Ruiz
034 * @author Joel Costigliola
035 */
036 // TODO inherits from IterableAssert and remove AbstractIterableAssert ?
037 public class ListAssert extends AbstractIterableAssert<ListAssert, List<?>> implements IndexedObjectEnumerableAssert {
038
039 @VisibleForTesting
040 Lists lists = Lists.instance();
041
042 protected ListAssert(List<?> actual) {
043 super(actual, ListAssert.class);
044 }
045
046 /** {@inheritDoc} */
047 public ListAssert contains(Object value, Index index) {
048 lists.assertContains(info, actual, value, index);
049 return this;
050 }
051
052 /** {@inheritDoc} */
053 public ListAssert doesNotContain(Object value, Index index) {
054 lists.assertDoesNotContain(info, actual, value, index);
055 return this;
056 }
057
058 /**
059 * Verifies that the actual list is sorted into ascending order according to the natural ordering of its elements.
060 * <p>
061 * All list elements must implement the {@link Comparable} interface and must be mutually comparable (that is,
062 * e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the list), examples :
063 * <ul>
064 * <li>a list composed of {"a1", "a2", "a3"} is ok because the element type (String) is Comparable</li>
065 * <li>a list composed of Rectangle {r1, r2, r3} is <b>NOT ok</b> because Rectangle is not Comparable</li>
066 * <li>a list composed of {True, "abc", False} is <b>NOT ok</b> because elements are not mutually comparable</li>
067 * </ul>
068 * Empty lists are considered sorted.</br> Unique element lists are considered sorted unless the element type is not
069 * Comparable.
070 *
071 * @return {@code this} assertion object.
072 *
073 * @throws AssertionError if the actual list is not sorted into ascending order according to the natural ordering of
074 * its elements.
075 * @throws AssertionError if the actual list is <code>null</code>.
076 * @throws AssertionError if the actual list element type does not implement {@link Comparable}.
077 * @throws AssertionError if the actual list elements are not mutually {@link Comparable}.
078 */
079 public ListAssert isSorted() {
080 lists.assertIsSorted(info, actual);
081 return this;
082 }
083
084 /**
085 * Verifies that the actual list is sorted according to the given comparator.</br> Empty lists are considered sorted
086 * whatever the comparator is.</br> One element lists are considered sorted if element is compatible with comparator.
087 *
088 * @param comparator the {@link Comparator} used to compare list elements
089 *
090 * @return {@code this} assertion object.
091 *
092 * @throws AssertionError if the actual list is not sorted according to the given comparator.
093 * @throws AssertionError if the actual list is <code>null</code>.
094 * @throws NullPointerException if the given comparator is <code>null</code>.
095 * @throws AssertionError if the actual list elements are not mutually comparabe according to given Comparator.
096 */
097 public ListAssert isSortedAccordingTo(Comparator<? extends Object> comparator) {
098 lists.assertIsSortedAccordingToComparator(info, actual, comparator);
099 return this;
100 }
101
102 @Override
103 public ListAssert usingComparator(Comparator<?> customComparator) {
104 super.usingComparator(customComparator);
105 this.lists = new Lists(new ComparatorBasedComparisonStrategy(customComparator));
106 return myself;
107 }
108
109 @Override
110 public ListAssert usingDefaultComparator() {
111 super.usingDefaultComparator();
112 this.lists = Lists.instance();
113 return myself;
114 }
115 }