001    /*
002     * Created on Dec 20, 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.internal;
016    
017    import java.util.Comparator;
018    
019    import org.fest.assertions.core.ArraySortedAssert;
020    import org.fest.assertions.core.AssertionInfo;
021    import org.fest.assertions.data.Index;
022    import org.fest.util.ComparisonStrategy;
023    import org.fest.util.StandardComparisonStrategy;
024    import org.fest.util.VisibleForTesting;
025    
026    /**
027     * Reusable assertions for arrays of {@code long}s.
028     *
029     * @author Alex Ruiz
030     * @author Joel Costigliola
031     */
032    public class LongArrays {
033    
034      private static final LongArrays INSTANCE = new LongArrays();
035    
036      /**
037       * Returns the singleton instance of this class.
038       * @return the singleton instance of this class.
039       */
040      public static LongArrays instance() {
041        return INSTANCE;
042      }
043    
044      private Arrays arrays = Arrays.instance();
045    
046      @VisibleForTesting Failures failures = Failures.instance();
047    
048      @VisibleForTesting LongArrays() {
049        this(StandardComparisonStrategy.instance());
050      }
051    
052      public LongArrays(ComparisonStrategy comparisonStrategy) {
053        this.arrays = new Arrays(comparisonStrategy);
054      }
055    
056      @VisibleForTesting
057      public Comparator<?> getComparator() {
058        return arrays.getComparator();
059      }
060    
061      /**
062       * Asserts that the given array is {@code null} or empty.
063       * @param info contains information about the assertion.
064       * @param actual the given array.
065       * @throws AssertionError if the given array is not {@code null} *and* contains one or more elements.
066       */
067      public void assertNullOrEmpty(AssertionInfo info, long[] actual) {
068        arrays.assertNullOrEmpty(info, failures, actual);
069      }
070    
071      /**
072       * Asserts that the given array is empty.
073       * @param info contains information about the assertion.
074       * @param actual the given array.
075       * @throws AssertionError if the given array is {@code null}.
076       * @throws AssertionError if the given array is not empty.
077       */
078      public void assertEmpty(AssertionInfo info, long[] actual) {
079        arrays.assertEmpty(info, failures, actual);
080      }
081    
082      /**
083       * Asserts that the given array is not empty.
084       * @param info contains information about the assertion.
085       * @param actual the given array.
086       * @throws AssertionError if the given array is {@code null}.
087       * @throws AssertionError if the given array is empty.
088       */
089      public void assertNotEmpty(AssertionInfo info, long[] actual) {
090        arrays.assertNotEmpty(info, failures, actual);
091      }
092    
093      /**
094       * Asserts that the number of elements in the given array is equal to the expected one.
095       * @param info contains information about the assertion.
096       * @param actual the given array.
097       * @param expectedSize the expected size of {@code actual}.
098       * @throws AssertionError if the given array is {@code null}.
099       * @throws AssertionError if the number of elements in the given array is different than the expected one.
100       */
101      public void assertHasSize(AssertionInfo info, long[] actual, int expectedSize) {
102        arrays.assertHasSize(info, failures, actual, expectedSize);
103      }
104    
105      /**
106       * Asserts that the given array contains the given values, in any order.
107       * @param info contains information about the assertion.
108       * @param actual the given array.
109       * @param values the values that are expected to be in the given array.
110       * @throws NullPointerException if the array of values is {@code null}.
111       * @throws IllegalArgumentException if the array of values is empty.
112       * @throws AssertionError if the given array is {@code null}.
113       * @throws AssertionError if the given array does not contain the given values.
114       */
115      public void assertContains(AssertionInfo info, long[] actual, long[] values) {
116        arrays.assertContains(info, failures, actual, values);
117      }
118    
119      /**
120       * Verifies that the given array contains the given value at the given index.
121       * @param info contains information about the assertion.
122       * @param actual the given array.
123       * @param value the value to look for.
124       * @param index the index where the value should be stored in the given array.
125       * @throws AssertionError if the given array is {@code null} or empty.
126       * @throws NullPointerException if the given {@code Index} is {@code null}.
127       * @throws IndexOutOfBoundsException if the value of the given {@code Index} is equal to or greater than the size of
128       * the given array.
129       * @throws AssertionError if the given array does not contain the given value at the given index.
130       */
131      public void assertContains(AssertionInfo info, long[] actual, long value, Index index) {
132        arrays.assertContains(info, failures, actual, value, index);
133      }
134    
135      /**
136       * Verifies that the given array does not contain the given value at the given index.
137       * @param info contains information about the assertion.
138       * @param actual the given array.
139       * @param value the value to look for.
140       * @param index the index where the value should be stored in the given array.
141       * @throws AssertionError if the given array is {@code null}.
142       * @throws NullPointerException if the given {@code Index} is {@code null}.
143       * @throws AssertionError if the given array contains the given value at the given index.
144       */
145      public void assertDoesNotContain(AssertionInfo info, long[] actual, long value, Index index) {
146        arrays.assertDoesNotContain(info, failures, actual, value, index);
147      }
148    
149      /**
150       * Asserts that the given array contains only the given values and nothing else, in any order.
151       * @param info contains information about the assertion.
152       * @param actual the given array.
153       * @param values the values that are expected to be in the given array.
154       * @throws NullPointerException if the array of values is {@code null}.
155       * @throws IllegalArgumentException if the array of values is empty.
156       * @throws AssertionError if the given array is {@code null}.
157       * @throws AssertionError if the given array does not contain the given values or if the given
158       * array contains values that are not in the given array.
159       */
160      public void assertContainsOnly(AssertionInfo info, long[] actual, long[] values) {
161        arrays.assertContainsOnly(info, failures, actual, values);
162      }
163    
164      /**
165       * Verifies that the given array contains the given sequence of values, without any other values between them.
166       * @param info contains information about the assertion.
167       * @param actual the given array.
168       * @param sequence the sequence of values to look for.
169       * @throws AssertionError if the given array is {@code null}.
170       * @throws NullPointerException if the given sequence is {@code null}.
171       * @throws IllegalArgumentException if the given sequence is empty.
172       * @throws AssertionError if the given array does not contain the given sequence of values.
173       */
174      public void assertContainsSequence(AssertionInfo info, long[] actual, long[] sequence) {
175        arrays.assertContainsSequence(info, failures, actual, sequence);
176      }
177    
178      /**
179       * Asserts that the given array does not contain the given values.
180       * @param info contains information about the assertion.
181       * @param actual the given array.
182       * @param values the values that are expected not to be in the given array.
183       * @throws NullPointerException if the array of values is {@code null}.
184       * @throws IllegalArgumentException if the array of values is empty.
185       * @throws AssertionError if the given array is {@code null}.
186       * @throws AssertionError if the given array contains any of given values.
187       */
188      public void assertDoesNotContain(AssertionInfo info, long[] actual, long[] values) {
189        arrays.assertDoesNotContain(info, failures, actual, values);
190      }
191    
192      /**
193       * Asserts that the given array does not have duplicate values.
194       * @param info contains information about the assertion.
195       * @param actual the given array.
196       * @throws NullPointerException if the array of values is {@code null}.
197       * @throws IllegalArgumentException if the array of values is empty.
198       * @throws AssertionError if the given array is {@code null}.
199       * @throws AssertionError if the given array contains duplicate values.
200       */
201      public void assertDoesNotHaveDuplicates(AssertionInfo info, long[] actual) {
202        arrays.assertDoesNotHaveDuplicates(info, failures, actual);
203      }
204    
205      /**
206       * Verifies that the given array starts with the given sequence of values, without any other values between them.
207       * Similar to <code>{@link #assertContainsSequence(AssertionInfo, long[], long[])}</code>, but it also verifies
208       * that the first element in the sequence is also the first element of the given array.
209       * @param info contains information about the assertion.
210       * @param actual the given array.
211       * @param sequence the sequence of values to look for.
212       * @throws NullPointerException if the given argument is {@code null}.
213       * @throws IllegalArgumentException if the given argument is an empty array.
214       * @throws AssertionError if the given array is {@code null}.
215       * @throws AssertionError if the given array does not start with the given sequence of values.
216       */
217      public void assertStartsWith(AssertionInfo info, long[] actual, long[] sequence) {
218        arrays.assertStartsWith(info, failures, actual, sequence);
219      }
220    
221      /**
222       * Verifies that the given array ends with the given sequence of values, without any other values between them.
223       * Similar to <code>{@link #assertContainsSequence(AssertionInfo, long[], long[])}</code>, but it also verifies
224       * that the last element in the sequence is also the last element of the given array.
225       * @param info contains information about the assertion.
226       * @param actual the given array.
227       * @param sequence the sequence of values to look for.
228       * @throws NullPointerException if the given argument is {@code null}.
229       * @throws IllegalArgumentException if the given argument is an empty array.
230       * @throws AssertionError if the given array is {@code null}.
231       * @throws AssertionError if the given array does not end with the given sequence of values.
232       */
233      public void assertEndsWith(AssertionInfo info, long[] actual, long[] sequence) {
234        arrays.assertEndsWith(info, failures, actual, sequence);
235      }
236    
237      /**
238       * Concrete implementation of {@link ArraySortedAssert#isSorted()}.
239       * 
240       * @param info contains information about the assertion.
241       * @param actual the given array.
242       */
243      public void assertIsSorted(AssertionInfo info, long[] actual) {
244        arrays.assertIsSorted(info, failures, actual);
245      }
246    
247      /**
248       * Concrete implementation of {@link ArraySortedAssert#isSortedAccordingTo(Comparator)}.
249       * 
250       * @param info contains information about the assertion.
251       * @param actual the given array.
252       * @param comparator the {@link Comparator} used to compare array elements
253       */
254      public void assertIsSortedAccordingToComparator(AssertionInfo info, long[] actual,
255          Comparator<? extends Long> comparator) {
256        Arrays.assertIsSortedAccordingToComparator(info, failures, actual, comparator);
257      }
258    }