001    /*
002     * Created on Dec 21, 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    
019    import org.fest.assertions.core.ArraySortedAssert;
020    import org.fest.assertions.core.EnumerableAssert;
021    import org.fest.assertions.data.Index;
022    import org.fest.assertions.internal.ShortArrays;
023    import org.fest.util.ComparatorBasedComparisonStrategy;
024    import org.fest.util.VisibleForTesting;
025    
026    /**
027     * Assertion methods for arrays of {@code short}s.
028     * <p>
029     * To create an instance of this class, invoke <code>{@link Assertions#assertThat(short[])}</code>.
030     * </p>
031     * 
032     * @author Yvonne Wang
033     * @author Alex Ruiz
034     * @author Joel Costigliola
035     */
036    public class ShortArrayAssert extends AbstractAssert<ShortArrayAssert, short[]> implements
037        EnumerableAssert<ShortArrayAssert>, ArraySortedAssert<ShortArrayAssert, Short> {
038    
039      @VisibleForTesting
040      ShortArrays arrays = ShortArrays.instance();
041    
042      protected ShortArrayAssert(short[] actual) {
043        super(actual, ShortArrayAssert.class);
044      }
045    
046      /** {@inheritDoc} */
047      public void isNullOrEmpty() {
048        arrays.assertNullOrEmpty(info, actual);
049      }
050    
051      /** {@inheritDoc} */
052      public void isEmpty() {
053        arrays.assertEmpty(info, actual);
054      }
055    
056      /** {@inheritDoc} */
057      public ShortArrayAssert isNotEmpty() {
058        arrays.assertNotEmpty(info, actual);
059        return this;
060      }
061    
062      /** {@inheritDoc} */
063      public ShortArrayAssert hasSize(int expected) {
064        arrays.assertHasSize(info, actual, expected);
065        return this;
066      }
067    
068      /**
069       * Verifies that the actual array contains the given values, in any order.
070       * @param values the given values.
071       * @return {@code this} assertion object.
072       * @throws NullPointerException if the given argument is {@code null}.
073       * @throws IllegalArgumentException if the given argument is an empty array.
074       * @throws AssertionError if the actual array is {@code null}.
075       * @throws AssertionError if the actual array does not contain the given values.
076       */
077      public ShortArrayAssert contains(short... values) {
078        arrays.assertContains(info, actual, values);
079        return this;
080      }
081    
082      /**
083       * Verifies that the actual array contains only the given values and nothing else, in any order.
084       * @param values the given values.
085       * @return {@code this} assertion object.
086       * @throws NullPointerException if the given argument is {@code null}.
087       * @throws IllegalArgumentException if the given argument is an empty array.
088       * @throws AssertionError if the actual array is {@code null}.
089       * @throws AssertionError if the actual array does not contain the given values, i.e. the actual array contains some
090       *           or none of the given values, or the actual array contains more values than the given ones.
091       */
092      public ShortArrayAssert containsOnly(short... values) {
093        arrays.assertContainsOnly(info, actual, values);
094        return this;
095      }
096    
097      /**
098       * Verifies that the actual array contains the given sequence, without any other values between them.
099       * @param sequence the sequence of values to look for.
100       * @return this assertion object.
101       * @throws AssertionError if the actual array is {@code null}.
102       * @throws AssertionError if the given array is {@code null}.
103       * @throws AssertionError if the actual array does not contain the given sequence.
104       */
105      public ShortArrayAssert containsSequence(short... sequence) {
106        arrays.assertContainsSequence(info, actual, sequence);
107        return this;
108      }
109    
110      /**
111       * Verifies that the actual array contains the given value at the given index.
112       * @param value the value to look for.
113       * @param index the index where the value should be stored in the actual array.
114       * @return this assertion object.
115       * @throws AssertionError if the actual array is {@code null} or empty.
116       * @throws NullPointerException if the given {@code Index} is {@code null}.
117       * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of
118       *           the actual array.
119       * @throws AssertionError if the actual array does not contain the given value at the given index.
120       */
121      public ShortArrayAssert contains(short value, Index index) {
122        arrays.assertContains(info, actual, value, index);
123        return this;
124      }
125    
126      /**
127       * Verifies that the actual array does not contain the given values.
128       * @param values the given values.
129       * @return {@code this} assertion object.
130       * @throws NullPointerException if the given argument is {@code null}.
131       * @throws IllegalArgumentException if the given argument is an empty array.
132       * @throws AssertionError if the actual array is {@code null}.
133       * @throws AssertionError if the actual array contains any of the given values.
134       */
135      public ShortArrayAssert doesNotContain(short... values) {
136        arrays.assertDoesNotContain(info, actual, values);
137        return this;
138      }
139    
140      /**
141       * Verifies that the actual array does not contain the given value at the given index.
142       * @param value the value to look for.
143       * @param index the index where the value should be stored in the actual array.
144       * @return this assertion object.
145       * @throws AssertionError if the actual array is {@code null}.
146       * @throws NullPointerException if the given {@code Index} is {@code null}.
147       * @throws AssertionError if the actual array contains the given value at the given index.
148       */
149      public ShortArrayAssert doesNotContain(short value, Index index) {
150        arrays.assertDoesNotContain(info, actual, value, index);
151        return this;
152      }
153    
154      /**
155       * Verifies that the actual array does not contain duplicates.
156       * @return {@code this} assertion object.
157       * @throws AssertionError if the actual array is {@code null}.
158       * @throws AssertionError if the actual array contains duplicates.
159       */
160      public ShortArrayAssert doesNotHaveDuplicates() {
161        arrays.assertDoesNotHaveDuplicates(info, actual);
162        return this;
163      }
164    
165      /**
166       * Verifies that the actual array starts with the given sequence of values, without any other values between them.
167       * Similar to <code>{@link #containsSequence(short...)}</code>, but it also verifies that the first element in the
168       * sequence is also first element of the actual array.
169       * @param sequence the sequence of values to look for.
170       * @return this assertion object.
171       * @throws NullPointerException if the given argument is {@code null}.
172       * @throws IllegalArgumentException if the given argument is an empty array.
173       * @throws AssertionError if the actual array is {@code null}.
174       * @throws AssertionError if the actual array does not start with the given sequence.
175       */
176      public ShortArrayAssert startsWith(short... sequence) {
177        arrays.assertStartsWith(info, actual, sequence);
178        return this;
179      }
180    
181      /**
182       * Verifies that the actual array ends with the given sequence of values, without any other values between them.
183       * Similar to <code>{@link #containsSequence(short...)}</code>, but it also verifies that the last element in the
184       * sequence is also last element of the actual array.
185       * @param sequence the sequence of values to look for.
186       * @return this assertion object.
187       * @throws NullPointerException if the given argument is {@code null}.
188       * @throws IllegalArgumentException if the given argument is an empty array.
189       * @throws AssertionError if the actual array is {@code null}.
190       * @throws AssertionError if the actual array does not end with the given sequence.
191       */
192      public ShortArrayAssert endsWith(short... sequence) {
193        arrays.assertEndsWith(info, actual, sequence);
194        return this;
195      }
196    
197      /** {@inheritDoc} */
198      public ShortArrayAssert isSorted() {
199        arrays.assertIsSorted(info, actual);
200        return this;
201      }
202    
203      /** {@inheritDoc} */
204      public ShortArrayAssert isSortedAccordingTo(Comparator<? extends Short> comparator) {
205        arrays.assertIsSortedAccordingToComparator(info, actual, comparator);
206        return this;
207      }
208    
209      @Override
210      public ShortArrayAssert usingComparator(Comparator<?> customComparator) {
211        super.usingComparator(customComparator);
212        this.arrays = new ShortArrays(new ComparatorBasedComparisonStrategy(customComparator));
213        return myself;
214      }
215    
216      @Override
217      public ShortArrayAssert usingDefaultComparator() {
218        super.usingDefaultComparator();
219        this.arrays = ShortArrays.instance();
220        return myself;
221      }
222    }