001: /*
002: * Licensed to the Apache Software Foundation (ASF) under one or more
003: * contributor license agreements. See the NOTICE file distributed with
004: * this work for additional information regarding copyright ownership.
005: * The ASF licenses this file to You under the Apache License, Version 2.0
006: * (the "License"); you may not use this file except in compliance with
007: * the License. You may obtain a copy of the License at
008: *
009: * http://www.apache.org/licenses/LICENSE-2.0
010: *
011: * Unless required by applicable law or agreed to in writing, software
012: * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
013: * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
014: * License for the specific language governing permissions and limitations under
015: * the License.
016: */
017:
018: package org.apache.harmony.luni.tests.java.util;
019:
020: import java.io.Serializable;
021: import java.util.Arrays;
022: import java.util.Comparator;
023: import java.util.List;
024: import java.util.RandomAccess;
025:
026: import junit.framework.TestCase;
027:
028: import org.apache.harmony.testframework.serialization.SerializationTest;
029:
030: public class Arrays2Test extends TestCase {
031:
032: /**
033: * @tests java.util.Arrays#binarySearch(double[], double)
034: */
035: public void test_binarySearch$DD() {
036: double[] specials = new double[] { Double.NEGATIVE_INFINITY,
037: -Double.MAX_VALUE, -2d, -Double.MIN_VALUE, -0d, 0d,
038: Double.MIN_VALUE, 2d, Double.MAX_VALUE,
039: Double.POSITIVE_INFINITY, Double.NaN };
040:
041: for (int i = 0; i < specials.length; i++) {
042: int result = Arrays.binarySearch(specials, specials[i]);
043: assertTrue("Assert 0: " + specials[i] + " invalid: "
044: + result, result == i);
045: }
046: assertEquals("Assert 1: Invalid search index for -1d", -4,
047: Arrays.binarySearch(specials, -1d));
048: assertEquals("Assert 2: Invalid search index for 1d", -8,
049: Arrays.binarySearch(specials, 1d));
050: }
051:
052: /**
053: * @tests java.util.Arrays#binarySearch(float[], float)
054: */
055: public void test_binarySearch$FF() {
056: float[] specials = new float[] { Float.NEGATIVE_INFINITY,
057: -Float.MAX_VALUE, -2f, -Float.MIN_VALUE, -0f, 0f,
058: Float.MIN_VALUE, 2f, Float.MAX_VALUE,
059: Float.POSITIVE_INFINITY, Float.NaN };
060:
061: for (int i = 0; i < specials.length; i++) {
062: int result = Arrays.binarySearch(specials, specials[i]);
063: assertTrue("Assert 0: " + specials[i] + " invalid: "
064: + result, result == i);
065: }
066: assertEquals("Assert 1: Invalid search index for -1f", -4,
067: Arrays.binarySearch(specials, -1f));
068: assertEquals("Assert 2: Invalid search index for 1f", -8,
069: Arrays.binarySearch(specials, 1f));
070: }
071:
072: /**
073: * @tests java.util.Arrays#equals(double[], double[])
074: */
075: public void test_equals$D$D() {
076: double d[] = new double[100];
077: double x[] = new double[100];
078: Arrays.fill(d, Double.MAX_VALUE);
079: Arrays.fill(x, Double.MIN_VALUE);
080:
081: assertTrue("Assert 0: Inequal arrays returned true", !Arrays
082: .equals(d, x));
083:
084: Arrays.fill(x, Double.MAX_VALUE);
085: assertTrue("Assert 1: equal arrays returned false", Arrays
086: .equals(d, x));
087:
088: assertTrue("Assert 2: should be false", !Arrays.equals(
089: new double[] { 1.0 }, new double[] { 2.0 }));
090:
091: assertTrue("Assert 3: NaN not equals", Arrays.equals(
092: new double[] { Double.NaN },
093: new double[] { Double.NaN }));
094: assertTrue("Assert 4: 0d equals -0d", !Arrays.equals(
095: new double[] { 0d }, new double[] { -0d }));
096: }
097:
098: /**
099: * @tests java.util.Arrays#equals(float[], float[])
100: */
101: public void test_equals$F$F() {
102: float d[] = new float[100];
103: float x[] = new float[100];
104: Arrays.fill(d, Float.MAX_VALUE);
105: Arrays.fill(x, Float.MIN_VALUE);
106:
107: assertTrue("Assert 0: Inequal arrays returned true", !Arrays
108: .equals(d, x));
109:
110: Arrays.fill(x, Float.MAX_VALUE);
111: assertTrue("Assert 1: equal arrays returned false", Arrays
112: .equals(d, x));
113:
114: assertTrue("Assert 2: NaN not equals", Arrays.equals(
115: new float[] { Float.NaN }, new float[] { Float.NaN }));
116: assertTrue("Assert 3: 0f equals -0f", !Arrays.equals(
117: new float[] { 0f }, new float[] { -0f }));
118: }
119:
120: /**
121: * @tests java.util.Arrays#sort(double[])
122: */
123: public void test_sort$D() {
124: // Test a basic sort
125: double[] reversedArray = new double[100];
126: for (int counter = 0; counter < reversedArray.length; counter++) {
127: reversedArray[counter] = (reversedArray.length - counter - 1);
128: }
129: Arrays.sort(reversedArray);
130: for (int counter = 0; counter < reversedArray.length; counter++) {
131: assertTrue("Assert 0: Resulting array not sorted",
132: reversedArray[counter] == counter);
133: }
134:
135: // These have to sort as per the Double compare ordering
136: double[] specials1 = new double[] { Double.NaN,
137: Double.MAX_VALUE, Double.MIN_VALUE, 0d, -0d,
138: Double.POSITIVE_INFINITY, Double.NEGATIVE_INFINITY };
139: double[] specials2 = new double[] { 0d,
140: Double.POSITIVE_INFINITY, -0d,
141: Double.NEGATIVE_INFINITY, Double.MIN_VALUE, Double.NaN,
142: Double.MAX_VALUE };
143: double[] answer = new double[] { Double.NEGATIVE_INFINITY, -0d,
144: 0d, Double.MIN_VALUE, Double.MAX_VALUE,
145: Double.POSITIVE_INFINITY, Double.NaN };
146:
147: Arrays.sort(specials1);
148: Object[] print1 = new Object[specials1.length];
149: for (int i = 0; i < specials1.length; i++) {
150: print1[i] = new Double(specials1[i]);
151: }
152: assertTrue("Assert 1: specials sort incorrectly"
153: + Arrays.asList(print1), Arrays.equals(specials1,
154: answer));
155:
156: Arrays.sort(specials2);
157: Object[] print2 = new Object[specials2.length];
158: for (int i = 0; i < specials2.length; i++) {
159: print2[i] = new Double(specials2[i]);
160: }
161: assertTrue("Assert 2: specials sort incorrectly "
162: + Arrays.asList(print2), Arrays.equals(specials2,
163: answer));
164: }
165:
166: /**
167: * @tests java.util.Arrays#sort(float[])
168: */
169: public void test_sort$F() {
170: // Test a basic sort
171: float[] reversedArray = new float[100];
172: for (int counter = 0; counter < reversedArray.length; counter++) {
173: reversedArray[counter] = (reversedArray.length - counter - 1);
174: }
175: Arrays.sort(reversedArray);
176: for (int counter = 0; counter < reversedArray.length; counter++) {
177: assertTrue("Assert 0: Resulting array not sorted",
178: reversedArray[counter] == counter);
179: }
180:
181: float[] specials1 = new float[] { Float.NaN, Float.MAX_VALUE,
182: Float.MIN_VALUE, 0f, -0f, Float.POSITIVE_INFINITY,
183: Float.NEGATIVE_INFINITY };
184: float[] specials2 = new float[] { 0f, Float.POSITIVE_INFINITY,
185: -0f, Float.NEGATIVE_INFINITY, Float.MIN_VALUE,
186: Float.NaN, Float.MAX_VALUE };
187: float[] answer = new float[] { Float.NEGATIVE_INFINITY, -0f,
188: 0f, Float.MIN_VALUE, Float.MAX_VALUE,
189: Float.POSITIVE_INFINITY, Float.NaN };
190:
191: Arrays.sort(specials1);
192: Object[] print1 = new Object[specials1.length];
193: for (int i = 0; i < specials1.length; i++) {
194: print1[i] = new Float(specials1[i]);
195: }
196: assertTrue("Assert 1: specials sort incorrectly"
197: + Arrays.asList(print1), Arrays.equals(specials1,
198: answer));
199:
200: Arrays.sort(specials2);
201: Object[] print2 = new Object[specials2.length];
202: for (int i = 0; i < specials2.length; i++) {
203: print2[i] = new Float(specials2[i]);
204: }
205: assertTrue("Assert 2: specials sort incorrectly"
206: + Arrays.asList(print2), Arrays.equals(specials2,
207: answer));
208: }
209:
210: /**
211: * @tests java.util.Arrays#toString(boolean[])
212: */
213: public void test_toString$Z() {
214: assertEquals("null", Arrays.toString((boolean[]) null));
215: assertEquals("[]", Arrays.toString(new boolean[] {}));
216: assertEquals("[true]", Arrays.toString(new boolean[] { true }));
217: assertEquals("[true, false]", Arrays.toString(new boolean[] {
218: true, false }));
219: assertEquals("[true, false, true]", Arrays
220: .toString(new boolean[] { true, false, true }));
221: }
222:
223: /**
224: * @tests java.util.Arrays#toString(byte[])
225: */
226: public void test_toString$B() {
227: assertEquals("null", Arrays.toString((byte[]) null));
228: assertEquals("[]", Arrays.toString(new byte[] {}));
229: assertEquals("[0]", Arrays.toString(new byte[] { 0 }));
230: assertEquals("[-1, 0]", Arrays.toString(new byte[] { -1, 0 }));
231: assertEquals("[-1, 0, 1]", Arrays.toString(new byte[] { -1, 0,
232: 1 }));
233: }
234:
235: /**
236: * @tests java.util.Arrays#toString(char[])
237: */
238: public void test_toString$C() {
239: assertEquals("null", Arrays.toString((char[]) null));
240: assertEquals("[]", Arrays.toString(new char[] {}));
241: assertEquals("[a]", Arrays.toString(new char[] { 'a' }));
242: assertEquals("[a, b]", Arrays.toString(new char[] { 'a', 'b' }));
243: assertEquals("[a, b, c]", Arrays.toString(new char[] { 'a',
244: 'b', 'c' }));
245: }
246:
247: /**
248: * @tests java.util.Arrays#toString(double[])
249: */
250: public void test_toString$D() {
251: assertEquals("null", Arrays.toString((double[]) null));
252: assertEquals("[]", Arrays.toString(new double[] {}));
253: assertEquals("[0.0]", Arrays.toString(new double[] { 0.0D }));
254: assertEquals("[-1.0, 0.0]", Arrays.toString(new double[] {
255: -1.0D, 0.0D }));
256: assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new double[] {
257: -1.0D, 0.0D, 1.0D }));
258: }
259:
260: /**
261: * @tests java.util.Arrays#toString(float[])
262: */
263: public void test_toString$F() {
264: assertEquals("null", Arrays.toString((float[]) null));
265: assertEquals("[]", Arrays.toString(new float[] {}));
266: assertEquals("[0.0]", Arrays.toString(new float[] { 0.0F }));
267: assertEquals("[-1.0, 0.0]", Arrays.toString(new float[] {
268: -1.0F, 0.0F }));
269: assertEquals("[-1.0, 0.0, 1.0]", Arrays.toString(new float[] {
270: -1.0F, 0.0F, 1.0F }));
271: }
272:
273: /**
274: * @tests java.util.Arrays#toString(int[])
275: */
276: public void test_toString$I() {
277: assertEquals("null", Arrays.toString((int[]) null));
278: assertEquals("[]", Arrays.toString(new int[] {}));
279: assertEquals("[0]", Arrays.toString(new int[] { 0 }));
280: assertEquals("[-1, 0]", Arrays.toString(new int[] { -1, 0 }));
281: assertEquals("[-1, 0, 1]", Arrays
282: .toString(new int[] { -1, 0, 1 }));
283: }
284:
285: /**
286: * @tests java.util.Arrays#toString(long[])
287: */
288: public void test_toString$J() {
289: assertEquals("null", Arrays.toString((long[]) null));
290: assertEquals("[]", Arrays.toString(new long[] {}));
291: assertEquals("[0]", Arrays.toString(new long[] { 0 }));
292: assertEquals("[-1, 0]", Arrays.toString(new long[] { -1, 0 }));
293: assertEquals("[-1, 0, 1]", Arrays.toString(new long[] { -1, 0,
294: 1 }));
295: }
296:
297: /**
298: * @tests java.util.Arrays#toString(short[])
299: */
300: public void test_toString$S() {
301: assertEquals("null", Arrays.toString((short[]) null));
302: assertEquals("[]", Arrays.toString(new short[] {}));
303: assertEquals("[0]", Arrays.toString(new short[] { 0 }));
304: assertEquals("[-1, 0]", Arrays.toString(new short[] { -1, 0 }));
305: assertEquals("[-1, 0, 1]", Arrays.toString(new short[] { -1, 0,
306: 1 }));
307: }
308:
309: /**
310: * @tests java.util.Arrays#toString(Object[])
311: */
312: public void test_toString$Ljava_lang_Object() {
313: assertEquals("null", Arrays.toString((Object[]) null));
314: assertEquals("[]", Arrays.toString(new Object[] {}));
315: assertEquals("[fixture]", Arrays
316: .toString(new Object[] { "fixture" }));
317: assertEquals("[fixture, null]", Arrays.toString(new Object[] {
318: "fixture", null }));
319: assertEquals("[fixture, null, fixture]", Arrays
320: .toString(new Object[] { "fixture", null, "fixture" }));
321: }
322:
323: /**
324: * @tests java.util.Arrays#deepToString(Object[])
325: */
326: public void test_deepToString$java_lang_Object() {
327: assertEquals("null", Arrays.deepToString((Object[]) null));
328: assertEquals("[]", Arrays.deepToString(new Object[] {}));
329: assertEquals("[fixture]", Arrays
330: .deepToString(new Object[] { "fixture" }));
331: assertEquals("[fixture, null]", Arrays
332: .deepToString(new Object[] { "fixture", null }));
333: assertEquals("[fixture, null, fixture]",
334: Arrays.deepToString(new Object[] { "fixture", null,
335: "fixture" }));
336:
337: Object[] fixture = new Object[1];
338: fixture[0] = fixture;
339: assertEquals("[[...]]", Arrays.deepToString(fixture));
340:
341: fixture = new Object[2];
342: fixture[0] = "fixture";
343: fixture[1] = fixture;
344: assertEquals("[fixture, [...]]", Arrays.deepToString(fixture));
345:
346: fixture = new Object[10];
347: fixture[0] = new boolean[] { true, false };
348: fixture[1] = new byte[] { 0, 1 };
349: fixture[2] = new char[] { 'a', 'b' };
350: fixture[3] = new double[] { 0.0D, 1.0D };
351: fixture[4] = new float[] { 0.0F, 1.0F };
352: fixture[5] = new int[] { 0, 1 };
353: fixture[6] = new long[] { 0L, 1L };
354: fixture[7] = new short[] { 0, 1 };
355: fixture[8] = fixture[0];
356: fixture[9] = new Object[9];
357: ((Object[]) fixture[9])[0] = fixture;
358: ((Object[]) fixture[9])[1] = fixture[1];
359: ((Object[]) fixture[9])[2] = fixture[2];
360: ((Object[]) fixture[9])[3] = fixture[3];
361: ((Object[]) fixture[9])[4] = fixture[4];
362: ((Object[]) fixture[9])[5] = fixture[5];
363: ((Object[]) fixture[9])[6] = fixture[6];
364: ((Object[]) fixture[9])[7] = fixture[7];
365: Object[] innerFixture = new Object[4];
366: innerFixture[0] = "innerFixture0";
367: innerFixture[1] = innerFixture;
368: innerFixture[2] = fixture;
369: innerFixture[3] = "innerFixture3";
370: ((Object[]) fixture[9])[8] = innerFixture;
371:
372: String expected = "[[true, false], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [true, false], [[...], [0, 1], [a, b], [0.0, 1.0], [0.0, 1.0], [0, 1], [0, 1], [0, 1], [innerFixture0, [...], [...], innerFixture3]]]";
373:
374: assertEquals(expected, Arrays.deepToString(fixture));
375: }
376:
377: public void test_asListTvararg() throws Exception {
378: List<String> stringsList = Arrays.asList("0", "1");
379: assertEquals(2, stringsList.size());
380: assertEquals("0", stringsList.get(0));
381: assertEquals("1", stringsList.get(1));
382: assertTrue(stringsList instanceof RandomAccess);
383: assertTrue(stringsList instanceof Serializable);
384:
385: assertEquals(stringsList, SerializationTest
386: .copySerializable((Serializable) stringsList));
387:
388: //test from javadoc
389: List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
390: assertEquals(3, stooges.size());
391: assertEquals("Larry", stooges.get(0));
392: assertEquals("Moe", stooges.get(1));
393: assertEquals("Curly", stooges.get(2));
394:
395: stringsList = Arrays.asList((String) null);
396: assertEquals(1, stringsList.size());
397: assertEquals((String) null, stringsList.get(0));
398:
399: try {
400: Arrays.asList((Object[]) null);
401: fail("No NPE");
402: } catch (NullPointerException e) {
403: }
404: }
405:
406: public void test_binarySearch$TTLjava_util_Comparatorsuper T() {
407: String[] strings = new String[] { "a", "B", "c", "D" };
408: Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);
409: assertEquals(0, Arrays.binarySearch(strings, "a",
410: String.CASE_INSENSITIVE_ORDER));
411: assertEquals(0, Arrays.binarySearch(strings, "A",
412: String.CASE_INSENSITIVE_ORDER));
413: assertEquals(1, Arrays.binarySearch(strings, "b",
414: String.CASE_INSENSITIVE_ORDER));
415: assertEquals(1, Arrays.binarySearch(strings, "B",
416: String.CASE_INSENSITIVE_ORDER));
417: assertEquals(2, Arrays.binarySearch(strings, "c",
418: String.CASE_INSENSITIVE_ORDER));
419: assertEquals(2, Arrays.binarySearch(strings, "C",
420: String.CASE_INSENSITIVE_ORDER));
421: assertEquals(3, Arrays.binarySearch(strings, "d",
422: String.CASE_INSENSITIVE_ORDER));
423: assertEquals(3, Arrays.binarySearch(strings, "D",
424: String.CASE_INSENSITIVE_ORDER));
425:
426: assertTrue(Arrays.binarySearch(strings, "e",
427: String.CASE_INSENSITIVE_ORDER) < 0);
428: assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1),
429: String.CASE_INSENSITIVE_ORDER) < 0);
430:
431: //test with null comparator, which switches back to Comparable
432: Arrays.sort(strings, null);
433: //B, D, a, c
434: assertEquals(2, Arrays.binarySearch(strings, "a",
435: (Comparator<String>) null));
436: assertEquals(-1, Arrays.binarySearch(strings, "A",
437: (Comparator<String>) null));
438: assertEquals(-4, Arrays.binarySearch(strings, "b",
439: (Comparator<String>) null));
440: assertEquals(0, Arrays.binarySearch(strings, "B",
441: (Comparator<String>) null));
442: assertEquals(3, Arrays.binarySearch(strings, "c",
443: (Comparator<String>) null));
444: assertEquals(-2, Arrays.binarySearch(strings, "C",
445: (Comparator<String>) null));
446: assertEquals(-5, Arrays.binarySearch(strings, "d",
447: (Comparator<String>) null));
448: assertEquals(1, Arrays.binarySearch(strings, "D",
449: (Comparator<String>) null));
450:
451: assertTrue(Arrays.binarySearch(strings, "e", null) < 0);
452: assertTrue(Arrays.binarySearch(strings, "" + ('A' - 1), null) < 0);
453:
454: try {
455: Arrays.binarySearch((String[]) null, "A",
456: String.CASE_INSENSITIVE_ORDER);
457: fail("No NPE");
458: } catch (NullPointerException e) {
459: }
460:
461: try {
462: Arrays.binarySearch(strings, (String) null,
463: String.CASE_INSENSITIVE_ORDER);
464: fail("No NPE");
465: } catch (NullPointerException e) {
466: }
467:
468: try {
469: Arrays.binarySearch(strings, (String) null,
470: (Comparator<String>) null);
471: fail("No NPE");
472: } catch (NullPointerException e) {
473: }
474:
475: }
476:
477: public void test_sort$TLjava_lang_Comparatorsuper T() {
478: String[] strings = new String[] { "a", "B", "c", "D" };
479: Arrays.sort(strings, String.CASE_INSENSITIVE_ORDER);
480: assertEquals("a", strings[0]);
481: assertEquals("B", strings[1]);
482: assertEquals("c", strings[2]);
483: assertEquals("D", strings[3]);
484:
485: //test with null comparator, which switches back to Comparable
486: Arrays.sort(strings, null);
487: //B, D, a, c
488: assertEquals("B", strings[0]);
489: assertEquals("D", strings[1]);
490: assertEquals("a", strings[2]);
491: assertEquals("c", strings[3]);
492:
493: try {
494: Arrays.sort((String[]) null, String.CASE_INSENSITIVE_ORDER);
495: fail("No NPE");
496: } catch (NullPointerException e) {
497: }
498: }
499:
500: public void test_sort$TIILjava_lang_Comparatorsuper T() {
501: String[] strings = new String[] { "a", "B", "c", "D" };
502: Arrays.sort(strings, 0, strings.length,
503: String.CASE_INSENSITIVE_ORDER);
504: assertEquals("a", strings[0]);
505: assertEquals("B", strings[1]);
506: assertEquals("c", strings[2]);
507: assertEquals("D", strings[3]);
508:
509: //test with null comparator, which switches back to Comparable
510: Arrays.sort(strings, 0, strings.length, null);
511: //B, D, a, c
512: assertEquals("B", strings[0]);
513: assertEquals("D", strings[1]);
514: assertEquals("a", strings[2]);
515: assertEquals("c", strings[3]);
516:
517: try {
518: Arrays.sort((String[]) null, String.CASE_INSENSITIVE_ORDER);
519: fail("No NPE");
520: } catch (NullPointerException e) {
521: }
522: }
523: }
|