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