jdk/test/java/util/Collections/ReverseOrder.java
changeset 16064 ef93558b0d63
parent 5506 202f599c92aa
child 23010 6dadb192ad81
equal deleted inserted replaced
16063:18e7ee7b4301 16064:ef93558b0d63
    21  * questions.
    21  * questions.
    22  */
    22  */
    23 
    23 
    24 /*
    24 /*
    25  * @test
    25  * @test
    26  * @bug 4593209
    26  * @bug 4593209 8001667
    27  * @summary Reverse comparator was subtly broken
    27  * @summary Reverse comparator was subtly broken
    28  * @author Josh bloch
    28  * @author Josh bloch
    29  */
    29  */
    30 
    30 
    31 import java.util.*;
    31 import java.util.*;
       
    32 import java.io.*;
    32 
    33 
    33 public class ReverseOrder {
    34 public class ReverseOrder {
       
    35     static byte[] serialBytes(Object o) {
       
    36         try {
       
    37             ByteArrayOutputStream bos = new ByteArrayOutputStream();
       
    38             ObjectOutputStream oos = new ObjectOutputStream(bos);
       
    39             oos.writeObject(o);
       
    40             oos.flush();
       
    41             oos.close();
       
    42             return bos.toByteArray();
       
    43         } catch (Throwable t) {
       
    44             throw new Error(t);
       
    45         }
       
    46     }
       
    47 
       
    48     @SuppressWarnings("unchecked")
       
    49     static <T> T serialClone(T o) {
       
    50         try {
       
    51             ObjectInputStream ois = new ObjectInputStream
       
    52                 (new ByteArrayInputStream(serialBytes(o)));
       
    53             T clone = (T) ois.readObject();
       
    54             return clone;
       
    55         } catch (Throwable t) {
       
    56             throw new Error(t);
       
    57         }
       
    58     }
       
    59 
    34     public static void main(String[] args) throws Exception {
    60     public static void main(String[] args) throws Exception {
    35         Foo[] a = { new Foo(2), new Foo(3), new Foo(1) };
    61         Foo[] a = { new Foo(2), new Foo(3), new Foo(1) };
    36         List list = Arrays.asList(a);
    62         List list = Arrays.asList(a);
    37         Collections.sort(list, Collections.reverseOrder());
    63         Comparator cmp = Collections.reverseOrder();
       
    64         Collections.sort(list, cmp);
    38 
    65 
    39         Foo[] golden = { new Foo(3), new Foo(2), new Foo(1) };
    66         Foo[] golden = { new Foo(3), new Foo(2), new Foo(1) };
    40         List goldenList = Arrays.asList(golden);
    67         List goldenList = Arrays.asList(golden);
    41         if (!list.equals(goldenList))
    68         if (!list.equals(goldenList))
       
    69             throw new Exception(list.toString());
       
    70 
       
    71         Comparator clone = serialClone(cmp);
       
    72         List list2 = Arrays.asList(a);
       
    73         Collections.sort(list2, clone);
       
    74         if (!list2.equals(goldenList))
    42             throw new Exception(list.toString());
    75             throw new Exception(list.toString());
    43     }
    76     }
    44 }
    77 }
    45 
    78 
    46 class Foo implements Comparable {
    79 class Foo implements Comparable {