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 * @author Mikhail Mazursky 036 */ 037 // TODO inherits from IterableAssert and remove AbstractIterableAssert ? 038 public class ListAssert<T> extends AbstractIterableAssert<ListAssert<T>, List<T>, T> implements IndexedObjectEnumerableAssert<T> { 039 040 @VisibleForTesting 041 Lists lists = Lists.instance(); 042 043 protected ListAssert(List<T> actual) { 044 super(actual, ListAssert.class); 045 } 046 047 /** {@inheritDoc} */ 048 public ListAssert<T> contains(T value, Index index) { 049 lists.assertContains(info, actual, value, index); 050 return this; 051 } 052 053 /** {@inheritDoc} */ 054 public ListAssert<T> doesNotContain(T value, Index index) { 055 lists.assertDoesNotContain(info, actual, value, index); 056 return this; 057 } 058 059 /** 060 * Verifies that the actual list is sorted into ascending order according to the natural ordering of its elements. 061 * <p> 062 * All list elements must implement the {@link Comparable} interface and must be mutually comparable (that is, 063 * e1.compareTo(e2) must not throw a ClassCastException for any elements e1 and e2 in the list), examples : 064 * <ul> 065 * <li>a list composed of {"a1", "a2", "a3"} is ok because the element type (String) is Comparable</li> 066 * <li>a list composed of Rectangle {r1, r2, r3} is <b>NOT ok</b> because Rectangle is not Comparable</li> 067 * <li>a list composed of {True, "abc", False} is <b>NOT ok</b> because elements are not mutually comparable</li> 068 * </ul> 069 * Empty lists are considered sorted.</br> Unique element lists are considered sorted unless the element type is not 070 * Comparable. 071 * 072 * @return {@code this} assertion object. 073 * 074 * @throws AssertionError if the actual list is not sorted into ascending order according to the natural ordering of 075 * its elements. 076 * @throws AssertionError if the actual list is <code>null</code>. 077 * @throws AssertionError if the actual list element type does not implement {@link Comparable}. 078 * @throws AssertionError if the actual list elements are not mutually {@link Comparable}. 079 */ 080 public ListAssert<T> isSorted() { 081 lists.assertIsSorted(info, actual); 082 return this; 083 } 084 085 /** 086 * Verifies that the actual list is sorted according to the given comparator.</br> Empty lists are considered sorted 087 * whatever the comparator is.</br> One element lists are considered sorted if element is compatible with comparator. 088 * 089 * @param comparator the {@link Comparator} used to compare list elements 090 * 091 * @return {@code this} assertion object. 092 * 093 * @throws AssertionError if the actual list is not sorted according to the given comparator. 094 * @throws AssertionError if the actual list is <code>null</code>. 095 * @throws NullPointerException if the given comparator is <code>null</code>. 096 * @throws AssertionError if the actual list elements are not mutually comparable according to given Comparator. 097 */ 098 public ListAssert<T> isSortedAccordingTo(Comparator<? super T> comparator) { 099 lists.assertIsSortedAccordingToComparator(info, actual, comparator); 100 return this; 101 } 102 103 @Override 104 public ListAssert<T> usingElementComparator(Comparator<? super T> customComparator) { 105 super.usingElementComparator(customComparator); 106 this.lists = new Lists(new ComparatorBasedComparisonStrategy(customComparator)); 107 return myself; 108 } 109 110 @Override 111 public ListAssert<T> usingDefaultElementComparator() { 112 super.usingDefaultElementComparator(); 113 this.lists = Lists.instance(); 114 return myself; 115 } 116 }