libjava/classpath/test/java.util/ArraysTest.java - rust-lang/gcc - Git at Google

 //////
 // There should be a copyright thing here but I'm in too much of a hurry to add
 // one right now. I don't care much what the copyright is though so if someone
 // wants to put the appropriate one here, go right ahead (I think GPL probably
 // unless that causes a problem with running on proprietory JVMs or testing
 // proprietory class libraries or anything.
 //////

 import java.util.*;

 /**
  * Test of most of the methods in the Arrays class. The class prints out a
  * single pass/fail message, and enumerates all failures. The message is in the
  * PASS: or FAIL: format that dejagnu uses, but other than that I don't know
  * enough to make it a "proper" testsuite.
  */
 public class ArraysTest {

   static int passed = 0;
   static int failed = 0;

   public static void main(String[] args) {
     testBool();
     testByte();
     testChar();
     testShort();
     testInt();
     testLong();
     testFloat();
     testDouble();
     testObject();
     if (failed != 0) {
       System.out.println(" (" + failed + " fails and " + passed + " passes).");
     } else {
       System.out.println("PASSED: [Arrays] All " + passed + " tests.");
     }
   }

   static void testBool() {
     boolean[] a1 = new boolean[] {true, false, false, true, true, false, true};
     boolean[] a2 = new boolean[] {false, false, false, true, true, true, true};
     boolean[] a3 = new boolean[] {true, false, false, true, true, false, true};
     passfail("boolean equals", !Arrays.equals(a1, a2) && Arrays.equals(a1, a3));
     Arrays.fill(a1, false);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == false;
     }
     passfail("boolean fill", filled);
   }

   static void testByte() {
     byte[] a1 = new byte[] {3, -2, 0, 1, 4, 0, -5};
     byte[] a2 = new byte[] {-5, -2, 0, 0, 1, 3, 4};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("byte sort", sorted);
     passfail("byte search", Arrays.binarySearch(a2, (byte)1) == 4 &&
                             Arrays.binarySearch(a2, (byte)-1) == -3);
     passfail("byte equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, (byte)6);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == (byte)6;
     }
     passfail("byte fill", filled);
   }

   static void testChar() {
     char[] a1 = new char[] {'i', 'd', 'f', 'g', 'j', 'f', 'a'};
     char[] a2 = new char[] {'a', 'd', 'f', 'f', 'g', 'i', 'j'};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("char sort", sorted);
     passfail("char search", Arrays.binarySearch(a2, 'i') == 5 &&
                             Arrays.binarySearch(a2, 'e') == -3);
     passfail("char equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, 'Q');
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == 'Q';
     }
     passfail("char fill", filled);
   }

   static void testShort() {
     short[] a1 = new short[] {3, -2, 0, 1, 4, 0, -5};
     short[] a2 = new short[] {-5, -2, 0, 0, 1, 3, 4};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("short sort", sorted);
     passfail("short search", Arrays.binarySearch(a2, (short)1) == 4 &&
                              Arrays.binarySearch(a2, (short)-1) == -3);
     passfail("short equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, (short)6);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == (short)6;
     }
     passfail("short fill", filled);
   }

   static void testInt() {
     int[] a1 = new int[] {3, -2, 0, 1, 4, 0, -5};
     int[] a2 = new int[] {-5, -2, 0, 0, 1, 3, 4};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("int sort", sorted);
     passfail("int search", Arrays.binarySearch(a2, 1) == 4 &&
                            Arrays.binarySearch(a2, -1) == -3);
     passfail("int equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, 6);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == 6;
     }
     passfail("int fill", filled);
   }

   static void testLong() {
     long[] a1 = new long[] {3, -2, 0, 1, 4, 0, -5};
     long[] a2 = new long[] {-5, -2, 0, 0, 1, 3, 4};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("long sort", sorted);
     passfail("long search", Arrays.binarySearch(a2, 1L) == 4 &&
                             Arrays.binarySearch(a2, -1L) == -3);
     passfail("long equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, 6L);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == 6L;
     }
     passfail("long fill", filled);
   }

   static void testFloat() {
     float[] a1 = new float[] {-4.0f, 75.3f, Float.POSITIVE_INFINITY, -0.0f,
                               -3324.342f, 0.0f, 3.14f, 2.5f, 1.0f, 1.0f};
     float[] a2 = new float[] {-3324.342f, -4.0f, -0.0f, 0.0f, 1.0f, 1.0f, 2.5f,
                               3.14f, 75.3f, Float.POSITIVE_INFINITY};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("float sort", sorted);
     passfail("float search", Arrays.binarySearch(a2, 3.14f) == 7 &&
                             Arrays.binarySearch(a2, -1.0f) == -3);
     passfail("float equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, 27.0f);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == 27.0f;
     }
     passfail("float fill", filled);
   }

   static void testDouble() {
     double[] a1 = new double[] {-4.0d, 75.3d, Double.POSITIVE_INFINITY, -0.0d,
                                 -3324.342d, 0.0d, 3.14d, 2.5d, 1.0d, 1.0d};
     double[] a2 = new double[] {-3324.342d, -4.0d, -0.0d, 0.0d, 1.0d, 1.0d,
                                 2.5d, 3.14d, 75.3d, Double.POSITIVE_INFINITY};
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
                                    // aren't tooo mean to NaNs
     }
     passfail("double sort", sorted);
     passfail("double search", Arrays.binarySearch(a2, 3.14d) == 7 &&
                             Arrays.binarySearch(a2, -1.0d) == -3);
     passfail("double equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, 27.0d);
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i] == 27.0d;
     }
     passfail("double fill", filled);
   }

   static void testObject() {
     String[] a1 = new String[] {"this", "is", "a", "string", "test", "which",
                                 "will", "hopefully", "demonstrate", "that",
                                 "sorting", "works"};
     String[] a2 = new String[] {"a", "demonstrate", "hopefully", "is",
                                 "sorting", "string", "test", "that", "this",
                                 "which", "will", "works"};
     String[] a3 = new String[] {"this", "is", "a", "reverse", "string", "test",
                                 "which", "will", "hopefully", "demonstrate",
                                 "that", "sorting", "works", "with",
                                 "comparators"};
     String[] a4 = new String[] {"works", "with", "will", "which", "this",
                                 "that", "test", "string", "sorting", "reverse",
                                 "is", "hopefully", "demonstrate", "comparators",
                                 "a"};
     final String list = "[works, with, will, which, this, that, test, string," +
                         " sorting, reverse, is, hopefully, demonstrate," +
                         " comparators, a]";
     boolean firstEq = Arrays.equals(a1, a2);
     Arrays.sort(a1);
     boolean sorted = true;
     for (int i = 0; sorted && i < a1.length - 1; i++) {
       sorted = a1[i].compareTo(a1[i+1]) <= 0;
     }
     passfail("object sort", sorted);
     passfail("object search", Arrays.binarySearch(a2, "hopefully") == 2 &&
                             Arrays.binarySearch(a2, "strange") == -6);
     passfail("object equals", !firstEq && Arrays.equals(a1, a2));
     Arrays.fill(a1, "blah");
     boolean filled = true;
     for (int i = 0; filled && i < a1.length; i++) {
       filled = a1[i].equals("blah");
     }
     passfail("object fill", filled);
     Comparator c = new ReverseOrder();
     Arrays.sort(a3, c);
     passfail("comparator sort", Arrays.equals(a3, a4));
     passfail("comparator search", Arrays.binarySearch(a4, "sorting", c) == 8 &&
                                   Arrays.binarySearch(a4, "nice", c) == -11);

     // toList doesn't exist -gcb
 //    passfail("toList toString", Arrays.toList(a4).toString().equals(list));
   }

   static void passfail(String desc, boolean didpass) {
     if (didpass) {
       passed++;
     } else {
       if (failed++ != 0) {
         System.out.print(", " + desc);
       } else {
         System.out.print("FAILED: [Arrays] " + desc);
       }
     }
   }
 }

 class ReverseOrder implements Comparator {
   public int compare(Object a, Object b) {
     return -((Comparable)a).compareTo(b);
   }
 }
	//////
	// There should be a copyright thing here but I'm in too much of a hurry to add
	// one right now. I don't care much what the copyright is though so if someone
	// wants to put the appropriate one here, go right ahead (I think GPL probably
	// unless that causes a problem with running on proprietory JVMs or testing
	// proprietory class libraries or anything.
	//////

	import java.util.*;

	/**
	* Test of most of the methods in the Arrays class. The class prints out a
	* single pass/fail message, and enumerates all failures. The message is in the
	* PASS: or FAIL: format that dejagnu uses, but other than that I don't know
	* enough to make it a "proper" testsuite.
	*/
	public class ArraysTest {

	static int passed = 0;
	static int failed = 0;

	public static void main(String[] args) {
	testBool();
	testByte();
	testChar();
	testShort();
	testInt();
	testLong();
	testFloat();
	testDouble();
	testObject();
	if (failed != 0) {
	System.out.println(" (" + failed + " fails and " + passed + " passes).");
	} else {
	System.out.println("PASSED: [Arrays] All " + passed + " tests.");
	}
	}

	static void testBool() {
	boolean[] a1 = new boolean[] {true, false, false, true, true, false, true};
	boolean[] a2 = new boolean[] {false, false, false, true, true, true, true};
	boolean[] a3 = new boolean[] {true, false, false, true, true, false, true};
	passfail("boolean equals", !Arrays.equals(a1, a2) && Arrays.equals(a1, a3));
	Arrays.fill(a1, false);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == false;
	}
	passfail("boolean fill", filled);
	}

	static void testByte() {
	byte[] a1 = new byte[] {3, -2, 0, 1, 4, 0, -5};
	byte[] a2 = new byte[] {-5, -2, 0, 0, 1, 3, 4};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("byte sort", sorted);
	passfail("byte search", Arrays.binarySearch(a2, (byte)1) == 4 &&
	Arrays.binarySearch(a2, (byte)-1) == -3);
	passfail("byte equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, (byte)6);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == (byte)6;
	}
	passfail("byte fill", filled);
	}

	static void testChar() {
	char[] a1 = new char[] {'i', 'd', 'f', 'g', 'j', 'f', 'a'};
	char[] a2 = new char[] {'a', 'd', 'f', 'f', 'g', 'i', 'j'};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("char sort", sorted);
	passfail("char search", Arrays.binarySearch(a2, 'i') == 5 &&
	Arrays.binarySearch(a2, 'e') == -3);
	passfail("char equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, 'Q');
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == 'Q';
	}
	passfail("char fill", filled);
	}

	static void testShort() {
	short[] a1 = new short[] {3, -2, 0, 1, 4, 0, -5};
	short[] a2 = new short[] {-5, -2, 0, 0, 1, 3, 4};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("short sort", sorted);
	passfail("short search", Arrays.binarySearch(a2, (short)1) == 4 &&
	Arrays.binarySearch(a2, (short)-1) == -3);
	passfail("short equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, (short)6);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == (short)6;
	}
	passfail("short fill", filled);
	}

	static void testInt() {
	int[] a1 = new int[] {3, -2, 0, 1, 4, 0, -5};
	int[] a2 = new int[] {-5, -2, 0, 0, 1, 3, 4};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("int sort", sorted);
	passfail("int search", Arrays.binarySearch(a2, 1) == 4 &&
	Arrays.binarySearch(a2, -1) == -3);
	passfail("int equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, 6);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == 6;
	}
	passfail("int fill", filled);
	}

	static void testLong() {
	long[] a1 = new long[] {3, -2, 0, 1, 4, 0, -5};
	long[] a2 = new long[] {-5, -2, 0, 0, 1, 3, 4};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("long sort", sorted);
	passfail("long search", Arrays.binarySearch(a2, 1L) == 4 &&
	Arrays.binarySearch(a2, -1L) == -3);
	passfail("long equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, 6L);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == 6L;
	}
	passfail("long fill", filled);
	}

	static void testFloat() {
	float[] a1 = new float[] {-4.0f, 75.3f, Float.POSITIVE_INFINITY, -0.0f,
	-3324.342f, 0.0f, 3.14f, 2.5f, 1.0f, 1.0f};
	float[] a2 = new float[] {-3324.342f, -4.0f, -0.0f, 0.0f, 1.0f, 1.0f, 2.5f,
	3.14f, 75.3f, Float.POSITIVE_INFINITY};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("float sort", sorted);
	passfail("float search", Arrays.binarySearch(a2, 3.14f) == 7 &&
	Arrays.binarySearch(a2, -1.0f) == -3);
	passfail("float equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, 27.0f);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == 27.0f;
	}
	passfail("float fill", filled);
	}

	static void testDouble() {
	double[] a1 = new double[] {-4.0d, 75.3d, Double.POSITIVE_INFINITY, -0.0d,
	-3324.342d, 0.0d, 3.14d, 2.5d, 1.0d, 1.0d};
	double[] a2 = new double[] {-3324.342d, -4.0d, -0.0d, 0.0d, 1.0d, 1.0d,
	2.5d, 3.14d, 75.3d, Double.POSITIVE_INFINITY};
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = !(a1[i] > a1[i+1]); // the odd way of writing <= is so that we
	// aren't tooo mean to NaNs
	}
	passfail("double sort", sorted);
	passfail("double search", Arrays.binarySearch(a2, 3.14d) == 7 &&
	Arrays.binarySearch(a2, -1.0d) == -3);
	passfail("double equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, 27.0d);
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i] == 27.0d;
	}
	passfail("double fill", filled);
	}

	static void testObject() {
	String[] a1 = new String[] {"this", "is", "a", "string", "test", "which",
	"will", "hopefully", "demonstrate", "that",
	"sorting", "works"};
	String[] a2 = new String[] {"a", "demonstrate", "hopefully", "is",
	"sorting", "string", "test", "that", "this",
	"which", "will", "works"};
	String[] a3 = new String[] {"this", "is", "a", "reverse", "string", "test",
	"which", "will", "hopefully", "demonstrate",
	"that", "sorting", "works", "with",
	"comparators"};
	String[] a4 = new String[] {"works", "with", "will", "which", "this",
	"that", "test", "string", "sorting", "reverse",
	"is", "hopefully", "demonstrate", "comparators",
	"a"};
	final String list = "[works, with, will, which, this, that, test, string," +
	" sorting, reverse, is, hopefully, demonstrate," +
	" comparators, a]";
	boolean firstEq = Arrays.equals(a1, a2);
	Arrays.sort(a1);
	boolean sorted = true;
	for (int i = 0; sorted && i < a1.length - 1; i++) {
	sorted = a1[i].compareTo(a1[i+1]) <= 0;
	}
	passfail("object sort", sorted);
	passfail("object search", Arrays.binarySearch(a2, "hopefully") == 2 &&
	Arrays.binarySearch(a2, "strange") == -6);
	passfail("object equals", !firstEq && Arrays.equals(a1, a2));
	Arrays.fill(a1, "blah");
	boolean filled = true;
	for (int i = 0; filled && i < a1.length; i++) {
	filled = a1[i].equals("blah");
	}
	passfail("object fill", filled);
	Comparator c = new ReverseOrder();
	Arrays.sort(a3, c);
	passfail("comparator sort", Arrays.equals(a3, a4));
	passfail("comparator search", Arrays.binarySearch(a4, "sorting", c) == 8 &&
	Arrays.binarySearch(a4, "nice", c) == -11);

	// toList doesn't exist -gcb
	// passfail("toList toString", Arrays.toList(a4).toString().equals(list));
	}

	static void passfail(String desc, boolean didpass) {
	if (didpass) {
	passed++;
	} else {
	if (failed++ != 0) {
	System.out.print(", " + desc);
	} else {
	System.out.print("FAILED: [Arrays] " + desc);
	}
	}
	}
	}

	class ReverseOrder implements Comparator {
	public int compare(Object a, Object b) {
	return -((Comparable)a).compareTo(b);
	}
	}