5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 6636323 6636319 7040220 7096080 7183053 8080248
  26  * @summary Test if StringCoding and NIO result have the same de/encoding result
  27  * @modules java.base/sun.nio.cs
  28  * @run main/othervm/timeout=2000 TestStringCoding
  29  * @key randomness
  30  */
  31 
  32 import java.util.*;
  33 import java.nio.*;
  34 import java.nio.charset.*;
  35 
  36 public class TestStringCoding {
  37     public static void main(String[] args) throws Throwable {
  38 














  39         for (Boolean hasSM: new boolean[] { false, true }) {
  40             if (hasSM)
  41                 System.setSecurityManager(new PermissiveSecurityManger());

  42             for (Charset cs:  Charset.availableCharsets().values()) {
  43                 if ("ISO-2022-CN".equals(cs.name()) ||
  44                     "x-COMPOUND_TEXT".equals(cs.name()) ||
  45                     "x-JISAutoDetect".equals(cs.name()))
  46                     continue;
  47                 System.out.printf("Testing(sm=%b) " + cs.name() + "....", hasSM);
  48                 // full bmp first
  49                 char[] bmpCA = new char[0x10000];
  50                 for (int i = 0; i < 0x10000; i++) {
  51                      bmpCA[i] = (char)i;
  52                 }
  53                 byte[] sbBA = new byte[0x100];
  54                 for (int i = 0; i < 0x100; i++) {
  55                     sbBA[i] = (byte)i;
  56                 }
  57                 test(cs, bmpCA, sbBA);
  58                 // "randomed" sizes
  59                 Random rnd = new Random();
  60                 for (int i = 0; i < 10; i++) {
  61                     int clen = rnd.nextInt(0x10000);
  62                     int blen = rnd.nextInt(0x100);
  63                     //System.out.printf("    blen=%d, clen=%d%n", blen, clen);
  64                     test(cs, Arrays.copyOf(bmpCA, clen), Arrays.copyOf(sbBA, blen));

  65                     //add a pair of surrogates
  66                     int pos = clen / 2;
  67                     if ((pos + 1) < blen) {
  68                         bmpCA[pos] = '\uD800';
  69                         bmpCA[pos+1] = '\uDC00';











  70                     }
  71                     test(cs, Arrays.copyOf(bmpCA, clen), Arrays.copyOf(sbBA, blen));
  72                 }
  73 
  74                 testMixed(cs);
  75                 System.out.println("done!");
  76             }
  77         }
  78     }
  79 
  80     static void testMixed(Charset cs) throws Throwable {
  81         CharsetDecoder dec = cs.newDecoder()
  82             .onMalformedInput(CodingErrorAction.REPLACE)
  83             .onUnmappableCharacter(CodingErrorAction.REPLACE);
  84         CharsetEncoder enc = cs.newEncoder()
  85             .onMalformedInput(CodingErrorAction.REPLACE)
  86             .onUnmappableCharacter(CodingErrorAction.REPLACE);
  87         List<Integer> cps = new ArrayList<>(0x10000);
  88         int off = 0;
  89         int cp = 0;
  90         while (cp < 0x10000) {
  91             if (enc.canEncode((char)cp)) {
  92                cps.add(cp);
  93             }
  94             cp++;
  95         }
  96         Collections.shuffle(cps);
  97         char[] bmpCA = new char[cps.size()];
  98         for (int i = 0; i < cps.size(); i++)
  99             bmpCA[i] = (char)(int)cps.get(i);
 100         String bmpStr = new String(bmpCA);
 101         //getBytes(csn);
 102         byte[] bmpBA = bmpStr.getBytes(cs.name());
 103         ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
 104         byte[] baNIO = new byte[bf.limit()];
 105         bf.get(baNIO, 0, baNIO.length);
 106         if (!Arrays.equals(bmpBA, baNIO)) {
 107             throw new RuntimeException("getBytes(csn) failed  -> " + cs.name());
 108         }
 109 
 110         //getBytes(cs);
 111         bmpBA = bmpStr.getBytes(cs);
 112         if (!Arrays.equals(bmpBA, baNIO))
 113             throw new RuntimeException("getBytes(cs) failed  -> " + cs.name());

 114 
 115         //new String(csn);
 116         String strSC = new String(bmpBA, cs.name());
 117         String strNIO = dec.reset().decode(ByteBuffer.wrap(bmpBA)).toString();
 118         if(!strNIO.equals(strSC)) {
 119             throw new RuntimeException("new String(csn) failed  -> " + cs.name());
 120         }
 121 
 122         //new String(cs);
 123         strSC = new String(bmpBA, cs);
 124         if (!strNIO.equals(strSC))
 125             throw new RuntimeException("new String(cs) failed  -> " + cs.name());


 126 





 127     }
 128 
 129     static void test(Charset cs, char[] bmpCA, byte[] sbBA) throws Throwable {
 130         String bmpStr = new String(bmpCA);
 131         CharsetDecoder dec = cs.newDecoder()
 132             .onMalformedInput(CodingErrorAction.REPLACE)
 133             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 134         CharsetEncoder enc = cs.newEncoder()
 135             .onMalformedInput(CodingErrorAction.REPLACE)
 136             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 137 
 138         //getBytes(csn);
 139         byte[] baSC = bmpStr.getBytes(cs.name());
 140         ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
 141         byte[] baNIO = new byte[bf.limit()];
 142         bf.get(baNIO, 0, baNIO.length);
 143         if (!Arrays.equals(baSC, baNIO))
 144             throw new RuntimeException("getBytes(csn) failed  -> " + cs.name());
 145 
 146         //getBytes(cs);
 147         baSC = bmpStr.getBytes(cs);
 148         if (!Arrays.equals(baSC, baNIO))
 149             throw new RuntimeException("getBytes(cs) failed  -> " + cs.name());



 150 




 151         //new String(csn);
 152         String strSC = new String(sbBA, cs.name());
 153         String strNIO = dec.reset().decode(ByteBuffer.wrap(sbBA)).toString();
 154 
 155         if(!strNIO.equals(strSC))
 156             throw new RuntimeException("new String(csn) failed  -> " + cs.name());
 157 
 158         //new String(cs);
 159         strSC = new String(sbBA, cs);
 160         if (!strNIO.equals(strSC))
 161             throw new RuntimeException("new String(cs) failed  -> " + cs.name());



 162 

 163         //encode unmappable surrogates



 164         if (enc instanceof sun.nio.cs.ArrayEncoder &&
 165             cs.contains(Charset.forName("ASCII"))) {
 166             if (cs.name().equals("UTF-8") ||     // utf8 handles surrogates
 167                 cs.name().equals("CESU-8"))      // utf8 handles surrogates
 168                 return;
 169             enc.replaceWith(new byte[] { (byte)'A'});
 170             sun.nio.cs.ArrayEncoder cae = (sun.nio.cs.ArrayEncoder)enc;
 171 
 172             String str = "ab\uD800\uDC00\uD800\uDC00cd";
 173             byte[] ba = new byte[str.length() - 2];
 174             int n = cae.encode(str.toCharArray(), 0, str.length(), ba);
 175             if (n != 6 || !"abAAcd".equals(new String(ba, cs.name())))
 176                 throw new RuntimeException("encode1(surrogates) failed  -> "
 177                                            + cs.name());
 178 
 179             ba = new byte[str.length()];
 180             n = cae.encode(str.toCharArray(), 0, str.length(), ba);
 181             if (n != 6 || !"abAAcd".equals(new String(ba, 0, n,
 182                                                      cs.name())))
 183                 throw new RuntimeException("encode2(surrogates) failed  -> "

   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.
   8  *
   9  * This code is distributed in the hope that it will be useful, but WITHOUT
  10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  12  * version 2 for more details (a copy is included in the LICENSE file that
  13  * accompanied this code).
  14  *
  15  * You should have received a copy of the GNU General Public License version
  16  * 2 along with this work; if not, write to the Free Software Foundation,
  17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  18  *
  19  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  20  * or visit www.oracle.com if you need additional information or have any
  21  * questions.
  22  */
  23 
  24 /* @test
  25  * @bug 6636323 6636319 7040220 7096080 7183053 8080248 8054307
  26  * @summary Test if StringCoding and NIO result have the same de/encoding result
  27  * @modules java.base/sun.nio.cs
  28  * @run main/othervm/timeout=2000 TestStringCoding
  29  * @key randomness
  30  */
  31 
  32 import java.util.*;
  33 import java.nio.*;
  34 import java.nio.charset.*;
  35 
  36 public class TestStringCoding {
  37     public static void main(String[] args) throws Throwable {
  38 
  39         // full bmp first
  40         char[] bmp = new char[0x10000];
  41         for (int i = 0; i < 0x10000; i++) {
  42             bmp[i] = (char)i;
  43         }
  44         char[] latin = Arrays.copyOf(bmp, 0x100);
  45         char[] ascii =  Arrays.copyOf(bmp, 0x80);
  46 
  47         byte[] latinBA = new byte[0x100];
  48         for (int i = 0; i < 0x100; i++) {
  49             latinBA[i] = (byte)i;
  50         }
  51         byte[] asciiBA =  Arrays.copyOf(latinBA, 0x80);
  52 
  53         for (Boolean hasSM: new boolean[] { false, true }) {
  54             if (hasSM) {
  55                 System.setSecurityManager(new PermissiveSecurityManger());
  56             }
  57             for (Charset cs:  Charset.availableCharsets().values()) {
  58                 if ("ISO-2022-CN".equals(cs.name()) ||
  59                     "x-COMPOUND_TEXT".equals(cs.name()) ||
  60                     "x-JISAutoDetect".equals(cs.name()))
  61                     continue;
  62                 System.out.printf("Testing(sm=%b) " + cs.name() + "....", hasSM);
  63 
  64                 testNewString(cs, testGetBytes(cs, new String(bmp)));
  65                 testNewString(cs, testGetBytes(cs, new String(latin)));
  66                 testNewString(cs, testGetBytes(cs, new String(ascii)));
  67                 testGetBytes(cs, testNewString(cs, latinBA));
  68                 testGetBytes(cs, testNewString(cs, asciiBA));
  69 



  70                 // "randomed" sizes
  71                 Random rnd = new Random();
  72                 for (int i = 0; i < 10; i++) {


  73                     //System.out.printf("    blen=%d, clen=%d%n", blen, clen);
  74                     char[] bmp0 = Arrays.copyOf(bmp, rnd.nextInt(0x10000));
  75                     testNewString(cs, testGetBytes(cs, new String(bmp0)));
  76                     //add a pair of surrogates
  77                     int pos = bmp0.length / 2;
  78                     if ((pos + 1) < bmp0.length) {
  79                         bmp0[pos] = '\uD800';
  80                         bmp0[pos+1] = '\uDC00';
  81                     }
  82                     testNewString(cs, testGetBytes(cs, new String(bmp0)));
  83 
  84                     char[] latin0 = Arrays.copyOf(latin, rnd.nextInt(0x100));
  85                     char[] ascii0 = Arrays.copyOf(ascii, rnd.nextInt(0x80));
  86                     byte[] latinBA0 = Arrays.copyOf(latinBA, rnd.nextInt(0x100));
  87                     byte[] asciiBA0 = Arrays.copyOf(asciiBA, rnd.nextInt(0x80));
  88                     testNewString(cs, testGetBytes(cs, new String(latin0)));
  89                     testNewString(cs, testGetBytes(cs, new String(ascii0)));
  90                     testGetBytes(cs, testNewString(cs, latinBA0));
  91                     testGetBytes(cs, testNewString(cs, asciiBA0));
  92                 }
  93                 testSurrogates(cs);


  94                 testMixed(cs);
  95                 System.out.println("done!");
  96             }
  97         }
  98     }
  99 
 100     static void testMixed(Charset cs) throws Throwable {
 101         CharsetDecoder dec = cs.newDecoder()
 102             .onMalformedInput(CodingErrorAction.REPLACE)
 103             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 104         CharsetEncoder enc = cs.newEncoder()
 105             .onMalformedInput(CodingErrorAction.REPLACE)
 106             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 107         List<Integer> cps = new ArrayList<>(0x10000);
 108         int off = 0;
 109         int cp = 0;
 110         while (cp < 0x10000) {
 111             if (enc.canEncode((char)cp)) {
 112                cps.add(cp);
 113             }
 114             cp++;
 115         }
 116         Collections.shuffle(cps);
 117         char[] bmpCA = new char[cps.size()];
 118         for (int i = 0; i < cps.size(); i++)
 119             bmpCA[i] = (char)(int)cps.get(i);
 120         String bmpStr = new String(bmpCA);
 121         //getBytes(csn);
 122         byte[] bmpBA = bmpStr.getBytes(cs.name());
 123         ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(bmpCA));
 124         byte[] baNIO = new byte[bf.limit()];
 125         bf.get(baNIO, 0, baNIO.length);
 126         if (!Arrays.equals(bmpBA, baNIO)) {
 127             throw new RuntimeException("getBytes(csn) failed  -> " + cs.name());
 128         }
 129 
 130         //getBytes(cs);
 131         bmpBA = bmpStr.getBytes(cs);
 132         if (!Arrays.equals(bmpBA, baNIO)) {
 133             throw new RuntimeException("getBytes(cs) failed  -> " + cs.name());
 134         }
 135 
 136         //new String(csn);
 137         String strSC = new String(bmpBA, cs.name());
 138         String strNIO = dec.reset().decode(ByteBuffer.wrap(bmpBA)).toString();
 139         if(!strNIO.equals(strSC)) {
 140             throw new RuntimeException("new String(csn) failed  -> " + cs.name());
 141         }

 142         //new String(cs);
 143         strSC = new String(bmpBA, cs);
 144         if (!strNIO.equals(strSC)) {
 145             throw new RuntimeException("new String(cs) failed  -> " + cs.name());
 146         }
 147     }
 148 
 149     static byte[] getBytes(CharsetEncoder enc, String str) throws Throwable {
 150         ByteBuffer bf = enc.reset().encode(CharBuffer.wrap(str.toCharArray()));
 151         byte[] ba = new byte[bf.limit()];
 152         bf.get(ba, 0, ba.length);
 153         return ba;
 154     }
 155 
 156     static byte[] testGetBytes(Charset cs, String str) throws Throwable {




 157         CharsetEncoder enc = cs.newEncoder()
 158             .onMalformedInput(CodingErrorAction.REPLACE)
 159             .onUnmappableCharacter(CodingErrorAction.REPLACE);

 160         //getBytes(csn);
 161         byte[] baSC = str.getBytes(cs.name());
 162         byte[] baNIO = getBytes(enc, str);
 163         if (!Arrays.equals(baSC, baNIO)) {


 164             throw new RuntimeException("getBytes(csn) failed  -> " + cs.name());
 165         }
 166         //getBytes(cs);
 167         baSC = str.getBytes(cs);
 168         if (!Arrays.equals(baSC, baNIO)) {
 169             throw new RuntimeException("getBytes(cs) failed  -> " + cs.name());
 170         }
 171         return baSC;
 172     }
 173 
 174     static String testNewString(Charset cs, byte[] ba) throws Throwable {
 175         CharsetDecoder dec = cs.newDecoder()
 176             .onMalformedInput(CodingErrorAction.REPLACE)
 177             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 178         //new String(csn);
 179         String strSC = new String(ba, cs.name());
 180         String strNIO = dec.reset().decode(ByteBuffer.wrap(ba)).toString();
 181         if(!strNIO.equals(strSC)) {

 182             throw new RuntimeException("new String(csn) failed  -> " + cs.name());
 183         }
 184         //new String(cs);
 185         strSC = new String(ba, cs);
 186         if (!strNIO.equals(strSC)) {
 187             throw new RuntimeException("new String(cs)/bmp failed  -> " + cs.name());
 188         }
 189         return strSC;
 190     }
 191 
 192     static void testSurrogates(Charset cs) throws Throwable {
 193         //encode unmappable surrogates
 194         CharsetEncoder enc = cs.newEncoder()
 195             .onMalformedInput(CodingErrorAction.REPLACE)
 196             .onUnmappableCharacter(CodingErrorAction.REPLACE);
 197         if (enc instanceof sun.nio.cs.ArrayEncoder &&
 198             cs.contains(Charset.forName("ASCII"))) {
 199             if (cs.name().equals("UTF-8") ||     // utf8 handles surrogates
 200                 cs.name().equals("CESU-8"))      // utf8 handles surrogates
 201                 return;
 202             enc.replaceWith(new byte[] { (byte)'A'});
 203             sun.nio.cs.ArrayEncoder cae = (sun.nio.cs.ArrayEncoder)enc;
 204 
 205             String str = "ab\uD800\uDC00\uD800\uDC00cd";
 206             byte[] ba = new byte[str.length() - 2];
 207             int n = cae.encode(str.toCharArray(), 0, str.length(), ba);
 208             if (n != 6 || !"abAAcd".equals(new String(ba, cs.name())))
 209                 throw new RuntimeException("encode1(surrogates) failed  -> "
 210                                            + cs.name());
 211 
 212             ba = new byte[str.length()];
 213             n = cae.encode(str.toCharArray(), 0, str.length(), ba);
 214             if (n != 6 || !"abAAcd".equals(new String(ba, 0, n,
 215                                                      cs.name())))
 216                 throw new RuntimeException("encode2(surrogates) failed  -> "