001    /*
002     * Created on Nov 18, 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.Collection;
018    import java.util.Comparator;
019    
020    import org.fest.assertions.core.Condition;
021    import org.fest.assertions.core.ObjectEnumerableAssert;
022    import org.fest.assertions.internal.Iterables;
023    import org.fest.util.ComparatorBasedComparisonStrategy;
024    import org.fest.util.VisibleForTesting;
025    
026    /**
027     * Base class for implementations of <code>{@link ObjectEnumerableAssert}</code> whose actual value type is
028     * <code>{@link Collection}</code>.
029     * @param <S> the "self" type of this assertion class. Please read &quot;<a href="http://bit.ly/anMa4g"
030     *          target="_blank">Emulating 'self types' using Java Generics to simplify fluent API implementation</a>&quot;
031     *          for more details.
032     * @param <A> the type of the "actual" value.
033     * @param <T> the type of elements of the "actual" value.
034     * 
035     * @author Yvonne Wang
036     * @author Alex Ruiz
037     * @author Mathieu Baechler
038     * @author Joel Costigliola
039     * @author Maciej Jaskowski
040     * @author Nicolas François
041     * @author Mikhail Mazursky
042     */
043    public abstract class AbstractIterableAssert<S extends AbstractIterableAssert<S, A, T>, A extends Iterable<T>, T> extends
044        AbstractAssert<S, A> implements ObjectEnumerableAssert<S, T> {
045    
046      @VisibleForTesting
047      Iterables iterables = Iterables.instance();
048    
049      protected AbstractIterableAssert(A actual, Class<?> selfType) {
050        super(actual, selfType);
051      }
052    
053      /** {@inheritDoc} */
054      public final void isNullOrEmpty() {
055        iterables.assertNullOrEmpty(info, actual);
056      }
057    
058      /** {@inheritDoc} */
059      public final void isEmpty() {
060        iterables.assertEmpty(info, actual);
061      }
062    
063      /** {@inheritDoc} */
064      public final S isNotEmpty() {
065        iterables.assertNotEmpty(info, actual);
066        return myself;
067      }
068    
069      /** {@inheritDoc} */
070      public final S hasSize(int expected) {
071        iterables.assertHasSize(info, actual, expected);
072        return myself;
073      }
074    
075      /** {@inheritDoc} */
076      public S hasSameSizeAs(Object[] other) {
077        iterables.assertHasSameSizeAs(info, actual, other);
078        return myself;
079      }
080    
081      /** {@inheritDoc} */
082      public S hasSameSizeAs(Iterable<?> other) {
083        iterables.assertHasSameSizeAs(info, actual, other);
084        return myself;
085      }
086    
087      /** {@inheritDoc} */
088      public final S contains(T... values) {
089        iterables.assertContains(info, actual, values);
090        return myself;
091      }
092    
093      /** {@inheritDoc} */
094      public final S containsOnly(T... values) {
095        iterables.assertContainsOnly(info, actual, values);
096        return myself;
097      }
098    
099      /**
100       * Verifies that all the elements of the actual {@code Iterable} are present in the given {@code Iterable}.
101       * @param values the {@code Iterable} that should contain all actual elements.
102       * @return this assertion object.
103       * @throws AssertionError if the actual {@code Iterable} is {@code null}.
104       * @throws NullPointerException if the given {@code Iterable} is {@code null}.
105       * @throws AssertionError if the actual {@code Iterable} is not subset of set {@code Iterable}.
106       */
107      public final S isSubsetOf(Iterable<? extends T> values) {
108        iterables.assertIsSubsetOf(info, actual, values);
109        return myself;
110      }
111    
112      /** {@inheritDoc} */
113      public final S containsSequence(T... sequence) {
114        iterables.assertContainsSequence(info, actual, sequence);
115        return myself;
116      }
117    
118      /** {@inheritDoc} */
119      public final S doesNotContain(T... values) {
120        iterables.assertDoesNotContain(info, actual, values);
121        return myself;
122      }
123    
124      /** {@inheritDoc} */
125      public final S doesNotHaveDuplicates() {
126        iterables.assertDoesNotHaveDuplicates(info, actual);
127        return myself;
128      }
129    
130      /** {@inheritDoc} */
131      public final S startsWith(T... sequence) {
132        iterables.assertStartsWith(info, actual, sequence);
133        return myself;
134      }
135    
136      /** {@inheritDoc} */
137      public final S endsWith(T... sequence) {
138        iterables.assertEndsWith(info, actual, sequence);
139        return myself;
140      }
141    
142      /** {@inheritDoc} */
143      public S containsNull() {
144        iterables.assertContainsNull(info, actual);
145        return myself;
146      }
147    
148      /** {@inheritDoc} */
149      public S doesNotContainNull() {
150        iterables.assertDoesNotContainNull(info, actual);
151        return myself;
152      }
153    
154      /** {@inheritDoc} */
155      public <E> S are(Condition<E> condition) {
156        iterables.assertAre(info, actual, condition);
157        return myself;
158      }
159    
160      /** {@inheritDoc} */
161      public <E> S areNot(Condition<E> condition) {
162        iterables.assertAreNot(info, actual, condition);
163        return myself;
164      }
165    
166      /** {@inheritDoc} */
167      public <E> S have(Condition<E> condition) {
168        iterables.assertHave(info, actual, condition);
169        return myself;
170      }
171    
172      /** {@inheritDoc} */
173      public <E> S doNotHave(Condition<E> condition) {
174        iterables.assertDoNotHave(info, actual, condition);
175        return myself;
176      }
177    
178      /** {@inheritDoc} */
179      public <E> S areAtLeast(int times, Condition<E> condition) {
180        iterables.assertAreAtLeast(info, actual, times, condition);
181        return myself;
182      }
183    
184      /** {@inheritDoc} */
185      public <E> S areNotAtLeast(int times, Condition<E> condition) {
186        iterables.assertAreNotAtLeast(info, actual, times, condition);
187        return myself;
188      }
189    
190      /** {@inheritDoc} */
191      public <E> S areAtMost(int times, Condition<E> condition) {
192        iterables.assertAreAtMost(info, actual, times, condition);
193        return myself;
194      }
195    
196      /** {@inheritDoc} */
197      public <E> S areNotAtMost(int times, Condition<E> condition) {
198        iterables.assertAreNotAtMost(info, actual, times, condition);
199        return myself;
200      }
201    
202      /** {@inheritDoc} */
203      public <E> S areExactly(int times, Condition<E> condition) {
204        iterables.assertAreExactly(info, actual, times, condition);
205        return myself;
206      }
207    
208      /** {@inheritDoc} */
209      public <E> S areNotExactly(int times, Condition<E> condition) {
210        iterables.assertAreNotExactly(info, actual, times, condition);
211        return myself;
212      }
213    
214      /** {@inheritDoc} */
215      public <E> S haveAtLeast(int times, Condition<E> condition) {
216        iterables.assertHaveAtLeast(info, actual, times, condition);
217        return myself;
218      }
219    
220      /** {@inheritDoc} */
221      public <E> S doNotHaveAtLeast(int times, Condition<E> condition) {
222        iterables.assertDoNotHaveAtLeast(info, actual, times, condition);
223        return myself;
224      }
225    
226      /** {@inheritDoc} */
227      public <E> S haveAtMost(int times, Condition<E> condition) {
228        iterables.assertHaveAtMost(info, actual, times, condition);
229        return myself;
230      }
231    
232      /** {@inheritDoc} */
233      public <E> S doNotHaveAtMost(int times, Condition<E> condition) {
234        iterables.assertDoNotHaveAtMost(info, actual, times, condition);
235        return myself;
236      }
237    
238      /** {@inheritDoc} */
239      public <E> S haveExactly(int times, Condition<E> condition) {
240        iterables.assertHaveExactly(info, actual, times, condition);
241        return myself;
242      }
243    
244      /** {@inheritDoc} */
245      public <E> S doNotHaveExactly(int times, Condition<E> condition) {
246        iterables.assertDoNotHaveExactly(info, actual, times, condition);
247        return myself;
248      }
249      
250      /** {@inheritDoc} */
251      public S containsAll(Iterable<? extends T> iterable) {
252        iterables.assertContainsAll(info, actual, iterable);
253        return myself;
254      }
255    
256      /** {@inheritDoc} */
257      public S usingElementComparator(Comparator<? super T> customComparator) {
258        this.iterables = new Iterables(new ComparatorBasedComparisonStrategy(customComparator));
259        return myself;
260      }
261    
262      /** {@inheritDoc} */
263      public S usingDefaultElementComparator() {
264        this.iterables = Iterables.instance();
265        return myself;
266      }
267    }