/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/
/*
* @test
* @bug 4906359 6239296
* @summary Basic test for content-based array object methods
* @author Josh Bloch, Martin Buchholz
*/
public class ArrayObjectMethods {
{
a[1] = a;
a[0] = a;
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
{
}
if (size <= 200) {
// Make deepCopy != a
if (size == 0)
else
}
}
}
// Utility method to turn an array into a list "deeply," turning
// all primitives into objects
for (Object e : a) {
if (e instanceof byte[])
else if (e instanceof short[])
else if (e instanceof int[])
else if (e instanceof long[])
else if (e instanceof char[])
else if (e instanceof double[])
else if (e instanceof float[])
else if (e instanceof boolean[])
else if (e instanceof Object[])
else
}
return result;
}
// Utility method to do a deep copy of an object *very slowly* using
try {
bos.toByteArray());
return ois.readObject();
} catch(Exception e) {
throw new IllegalArgumentException(e);
}
}
//--------------------- Infrastructure ---------------------------
else fail(x + " not equal to " + y);}
}
/**
* Methods to generate "interesting" random primitives and primitive
* arrays. Unlike Random.nextXxx, these methods return small values
* and boundary values (e.g., 0, -1, NaN) with greater than normal
* likelihood.
*/
class Rnd {
public static long nextLong() {
case 0: return 0;
case 3: case 4: case 5:
}
}
public static int nextInt() {
case 0: return 0;
case 3: case 4: case 5:
}
}
public static short nextShort() {
case 0: return 0;
case 3: case 4: case 5:
}
}
public static char nextChar() {
case 0: return 0;
case 3: case 4: case 5:
}
}
public static byte nextByte() {
case 0: return 0;
case 3: case 4: case 5:
}
}
public static boolean nextBoolean() {
return rnd.nextBoolean();
}
public static double nextDouble() {
case 0: return 0;
case 1: return -0.0;
case 7: case 8: case 9:
default: return rnd.nextDouble();
}
}
public static float nextFloat() {
case 0: return 0;
case 1: return -0.0f;
case 7: case 8: case 9:
}
}
case 0: return null;
case 1: return "foo";
case 2: case 3: case 4:
}
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
for (int i = 0; i < length; i++)
return result;
}
// Calling this for length >> 100 is likely to run out of memory! It
// should be perhaps be tuned to allow for longer arrays
for (int i = 0; i < length; i++) {
break;
break;
break;
break;
break;
break;
break;
break;
break;
}
}
return result;
}
}
/**
* Primitive arrays viewed as lists. Inefficient but cool.
* This utility should be generally useful in writing regression/unit/basic
* tests.
*/
class PrimitiveArrays {
return new AbstractList<Long>() {
long oldVal = a[i];
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Integer>() {
int oldVal = a[i];
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Short>() {
short oldVal = a[i];
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Character>() {
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Byte>() {
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Boolean>() {
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Double>() {
a[i] = e;
return oldVal;
}
};
}
return new AbstractList<Float>() {
a[i] = e;
return oldVal;
}
};
}
}