// from gee.cs.oswego.edu/home/jsr166/jsr166
package jsr166tests.loops;
/*
* Written by Josh Bloch and Doug Lea with assistance from members of
* JCP JSR-166 Expert Group and released to the public domain, as
* explained at http://creativecommons.org/licenses/publicdomain
*/
import java.util.*;
public class ListBash {
static boolean canRemove = true;
static final Random rnd = new Random();
static int numItr;
static int listSize;
static boolean synch;
static Class cl;
public static void main(String[] args) {
numItr = Integer.parseInt(args[1]);
listSize = Integer.parseInt(args[2]);
cl = null;
try {
cl = Class.forName(args[0]);
} catch (ClassNotFoundException e) {
fail("Class " + args[0] + " not found.");
}
synch = (args.length>3);
oneRun();
oneRun();
oneRun();
}
static void oneRun() {
long startTime = System.nanoTime();
for (int i=0; i<numItr; i++) {
elementLoop();
}
List<Integer> s = newList(cl, synch);
for (int i=0; i<listSize; i++)
s.add(new Integer(i));
if (s.size() != listSize)
fail("Size of [0..n-1] != n");
evenOdd(s);
sublists(s);
arrays();
long elapsed = System.nanoTime() - startTime;
System.out.println("Time: " + (elapsed/1000000000.0) + "s");
}
static void elementLoop() {
List<Integer> s1 = newList(cl, synch);
AddRandoms(s1, listSize);
List<Integer> s2 = newList(cl, synch);
AddRandoms(s2, listSize);
sets(s1, s2);
s1.clear();
if (s1.size() != 0)
fail("Clear didn't reduce size to zero.");
s1.addAll(0, s2);
if (!(s1.equals(s2) && s2.equals(s1)))
fail("addAll(int, Collection) doesn't work.");
// Reverse List
for (int j=0, n=s1.size(); j<n; j++)
s1.set(j, s1.set(n-j-1, s1.get(j)));
// Reverse it again
for (int j=0, n=s1.size(); j<n; j++)
s1.set(j, s1.set(n-j-1, s1.get(j)));
if (!(s1.equals(s2) && s2.equals(s1)))
fail("set(int, Object) doesn't work");
sums(s1, s2);
}
static void sums(List<Integer> s1, List<Integer> s2) {
int sum = 0;
for (int k = 0; k < listSize; ++k) {
sum += (s1.get(k)).intValue();
sum -= (s2.get(k)).intValue();
}
for (int k = 0; k < listSize; ++k) {
sum += (s1.get(k)).intValue();
s1.set(k, sum);
sum -= (s2.get(k)).intValue();
s1.set(k, -sum);
}
for (int k = 0; k < listSize; ++k) {
sum += (s1.get(k)).intValue();
sum -= (s2.get(k)).intValue();
}
if (sum == 0) System.out.print(" ");
}
static void sets(List<Integer> s1, List<Integer> s2) {
List<Integer> intersection = clone(s1, cl,synch);intersection.retainAll(s2);
List<Integer> diff1 = clone(s1, cl, synch); diff1.removeAll(s2);
List<Integer> diff2 = clone(s2, cl, synch); diff2.removeAll(s1);
List<Integer> union = clone(s1, cl, synch); union.addAll(s2);
if (diff1.removeAll(diff2))
fail("List algebra identity 2 failed");
if (diff1.removeAll(intersection))
fail("List algebra identity 3 failed");
if (diff2.removeAll(diff1))
fail("List algebra identity 4 failed");
if (diff2.removeAll(intersection))
fail("List algebra identity 5 failed");
if (intersection.removeAll(diff1))
fail("List algebra identity 6 failed");
if (intersection.removeAll(diff1))
fail("List algebra identity 7 failed");
intersection.addAll(diff1); intersection.addAll(diff2);
if (!(intersection.containsAll(union) &&
union.containsAll(intersection)))
fail("List algebra identity 1 failed");
Iterator e = union.iterator();
while (e.hasNext())
intersection.remove(e.next());
if (!intersection.isEmpty())
fail("Copy nonempty after deleting all elements.");
e = union.iterator();
while (e.hasNext()) {
Object o = e.next();
if (!union.contains(o))
fail("List doesn't contain one of its elements.");
if (canRemove) {
try { e.remove();
} catch (UnsupportedOperationException uoe) {
canRemove = false;
}
}
}
if (canRemove && !union.isEmpty())
fail("List nonempty after deleting all elements.");
}
static void evenOdd(List<Integer> s) {
List<Integer> even = clone(s, cl, synch);
List<Integer> odd = clone(s, cl, synch);
List<Integer> all;
Iterator<Integer> it;
if (!canRemove)
all = clone(s, cl, synch);
else {
it = even.iterator();
while (it.hasNext())
if ((it.next()).intValue() % 2 == 1)
it.remove();
it = even.iterator();
while (it.hasNext())
if ((it.next()).intValue() % 2 == 1)
fail("Failed to remove all odd nubmers.");
for (int i=0; i<(listSize/2); i++)
odd.remove(i);
for (int i=0; i<(listSize/2); i++) {
int ii = (odd.get(i)).intValue();
if (ii % 2 != 1)
fail("Failed to remove all even nubmers. " + ii);
}
all = clone(odd, cl, synch);
for (int i=0; i<(listSize/2); i++)
all.add(2*i, even.get(i));
if (!all.equals(s))
fail("Failed to reconstruct ints from odds and evens.");
all = clone(odd, cl, synch);
ListIterator<Integer> itAll = all.listIterator(all.size());
ListIterator<Integer> itEven = even.listIterator(even.size());
while (itEven.hasPrevious()) {
itAll.previous();
itAll.add(itEven.previous());
itAll.previous(); // ???
}
itAll = all.listIterator();
while (itAll.hasNext()) {
Integer i = itAll.next();
itAll.set(new Integer(i.intValue()));
}
itAll = all.listIterator();
it = s.iterator();
while (it.hasNext())
if (it.next()==itAll.next())
fail("Iterator.set failed to change value.");
}
if (!all.equals(s))
fail("Failed to reconstruct ints with ListIterator.");
}
static void sublists(List<Integer> s) {
List<Integer> all = clone(s, cl, synch);
Iterator it = all.listIterator();
int i=0;
while (it.hasNext()) {
Object o = it.next();
if (all.indexOf(o) != all.lastIndexOf(o))
fail("Apparent duplicate detected.");
if (all.subList(i, all.size()).indexOf(o) != 0) {
System.out.println("s0: " + all.subList(i, all.size()).indexOf(o));
fail("subList/indexOf is screwy.");
}
if (all.subList(i+1, all.size()).indexOf(o) != -1) {
System.out.println("s-1: " + all.subList(i+1, all.size()).indexOf(o));
fail("subList/indexOf is screwy.");
}
if (all.subList(0,i+1).lastIndexOf(o) != i) {
System.out.println("si" + all.subList(0,i+1).lastIndexOf(o));
fail("subList/lastIndexOf is screwy.");
}
i++;
}
}
static void arrays() {
List<Integer> l = newList(cl, synch);
AddRandoms(l, listSize);
Integer[] ia = l.toArray(new Integer[0]);
if (!l.equals(Arrays.asList(ia)))
fail("toArray(Object[]) is hosed (1)");
ia = new Integer[listSize];
Integer[] ib = l.toArray(ia);
if (ia != ib || !l.equals(Arrays.asList(ia)))
fail("toArray(Object[]) is hosed (2)");
ia = new Integer[listSize+1];
ia[listSize] = new Integer(69);
ib = l.toArray(ia);
if (ia != ib || ia[listSize] != null
|| !l.equals(Arrays.asList(ia).subList(0, listSize)))
fail("toArray(Object[]) is hosed (3)");
}
// Done inefficiently so as to exercise toArray
static List<Integer> clone(List s, Class cl, boolean synch) {
List a = Arrays.asList(s.toArray());
if (s.hashCode() != a.hashCode())
fail("Incorrect hashCode computation.");
List clone = newList(cl, synch);
clone.addAll(a);
if (!s.equals(clone))
fail("List not equal to copy.");
if (!s.containsAll(clone))
fail("List does not contain copy.");
if (!clone.containsAll(s))
fail("Copy does not contain list.");
return (List<Integer>) clone;
}
static List<Integer> newList(Class cl, boolean synch) {
try {
List<Integer> s = (List<Integer>) cl.newInstance();
if (synch)
s = Collections.synchronizedList(s);
if (!s.isEmpty())
fail("New instance non empty.");
return s;
} catch (Throwable t) {
fail("Can't instantiate " + cl + ": " + t);
}
return null; //Shut up compiler.
}
static void AddRandoms(List<Integer> s, int n) {
for (int i=0; i<n; i++) {
int r = rnd.nextInt() % n;
Integer e = new Integer(r < 0 ? -r : r);
int preSize = s.size();
if (!s.add(e))
fail ("Add failed.");
int postSize = s.size();
if (postSize-preSize != 1)
fail ("Add didn't increase size by 1.");
}
}
static void fail(String s) {
System.out.println(s);
System.exit(1);
}
}