jdk/test/java/util/Scanner/ScanTest.java
changeset 41824 ebb396875090
parent 39141 e5d52546ba3a
child 46150 d3385f62b9e8
equal deleted inserted replaced
41823:10b6e8a41af5 41824:ebb396875090
    22  */
    22  */
    23 
    23 
    24 /**
    24 /**
    25  * @test
    25  * @test
    26  * @bug 4313885 4926319 4927634 5032610 5032622 5049968 5059533 6223711 6277261 6269946 6288823
    26  * @bug 4313885 4926319 4927634 5032610 5032622 5049968 5059533 6223711 6277261 6269946 6288823
    27  *      8072722 8139414
    27  *      8072722 8139414 8166261
    28  * @summary Basic tests of java.util.Scanner methods
    28  * @summary Basic tests of java.util.Scanner methods
    29  * @key randomness
    29  * @key randomness
    30  * @modules jdk.localedata
    30  * @modules jdk.localedata
    31  * @run main/othervm ScanTest
    31  * @run main/othervm ScanTest
    32  */
    32  */
    34 import java.io.*;
    34 import java.io.*;
    35 import java.math.*;
    35 import java.math.*;
    36 import java.nio.*;
    36 import java.nio.*;
    37 import java.text.*;
    37 import java.text.*;
    38 import java.util.*;
    38 import java.util.*;
       
    39 import java.util.function.BiConsumer;
    39 import java.util.function.Consumer;
    40 import java.util.function.Consumer;
    40 import java.util.regex.*;
    41 import java.util.regex.*;
    41 import java.util.stream.*;
    42 import java.util.stream.*;
    42 
    43 
    43 public class ScanTest {
    44 public class ScanTest {
    77             cacheTest2();
    78             cacheTest2();
    78             nonASCIITest();
    79             nonASCIITest();
    79             resetTest();
    80             resetTest();
    80             streamCloseTest();
    81             streamCloseTest();
    81             streamComodTest();
    82             streamComodTest();
       
    83             outOfRangeRadixTest();
    82 
    84 
    83             for (int j = 0; j < NUM_SOURCE_TYPES; j++) {
    85             for (int j = 0; j < NUM_SOURCE_TYPES; j++) {
    84                 hasNextTest(j);
    86                 hasNextTest(j);
    85                 nextTest(j);
    87                 nextTest(j);
    86                 hasNextPatternTest(j);
    88                 hasNextPatternTest(j);
  1507         }
  1509         }
  1508         sc.close();
  1510         sc.close();
  1509         report("Reset test");
  1511         report("Reset test");
  1510     }
  1512     }
  1511 
  1513 
       
  1514     static List<BiConsumer <Scanner, Integer>> methodWRList = Arrays.asList(
       
  1515         (s, r) -> s.hasNextByte(r),
       
  1516         (s, r) -> s.nextByte(r),
       
  1517         (s, r) -> s.hasNextShort(r),
       
  1518         (s, r) -> s.nextShort(r),
       
  1519         (s, r) -> s.hasNextInt(r),
       
  1520         (s, r) -> s.nextInt(r),
       
  1521         (s, r) -> s.hasNextLong(r),
       
  1522         (s, r) -> s.nextLong(r),
       
  1523         (s, r) -> s.hasNextBigInteger(r),
       
  1524         (s, r) -> s.nextBigInteger(r)
       
  1525     );
       
  1526 
       
  1527     /*
       
  1528      * Test that setting the radix to an out of range value triggers
       
  1529      * an IllegalArgumentException
       
  1530      */
       
  1531     public static void outOfRangeRadixTest() throws Exception {
       
  1532         int[] bad = new int[] { -1, 0,  1, 37, 38 };
       
  1533         int[] good = IntStream.rangeClosed(Character.MIN_RADIX, Character.MAX_RADIX)
       
  1534                               .toArray();
       
  1535 
       
  1536         methodWRList.stream().forEach( m -> {
       
  1537             for (int r : bad) {
       
  1538                 try (Scanner sc = new Scanner("10 10 10 10")) {
       
  1539                     m.accept(sc, r);
       
  1540                     failCount++;
       
  1541                 } catch (IllegalArgumentException ise) {}
       
  1542             }
       
  1543         });
       
  1544         methodWRList.stream().forEach( m -> {
       
  1545             for (int r : good) {
       
  1546                 try (Scanner sc = new Scanner("10 10 10 10")) {
       
  1547                     m.accept(sc, r);
       
  1548                 } catch (Exception x) {
       
  1549                     failCount++;
       
  1550                 }
       
  1551             }
       
  1552         });
       
  1553         report("Radix out of range test");
       
  1554     }
       
  1555 
  1512     /*
  1556     /*
  1513      * Test that closing the stream also closes the underlying Scanner.
  1557      * Test that closing the stream also closes the underlying Scanner.
  1514      * The cases of attempting to open streams on a closed Scanner are
  1558      * The cases of attempting to open streams on a closed Scanner are
  1515      * covered by closeTest().
  1559      * covered by closeTest().
  1516      */
  1560      */