1 /*

     2  * Copyright (c) 2018, Oracle and/or its affiliates. All rights reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     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 import static java.nio.charset.StandardCharsets.UTF_8;

    25 

    26 import java.io.ByteArrayInputStream;

    27 import java.io.ByteArrayOutputStream;

    28 import java.io.IOException;

    29 import java.util.jar.Attributes;

    30 import java.util.jar.Attributes.Name;

    31 import java.util.jar.Manifest;

    32 import java.util.List;

    33 import java.util.ArrayList;

    34 

    35 import org.testng.annotations.Test;

    36 import static org.testng.Assert.*;

    37 

    38 /**

    39  * @test

    40  * @bug 8066619

    41  * @run testng ValueUtf8Coding

    42  * @summary Tests encoding and decoding manifest header values to and from

    43  * UTF-8 with the complete Unicode character set.

    44  */ /*

    45  * see also "../tools/launcher/UnicodeTest.java" for manifest attributes

    46  * parsed during launch

    47  */

    48 public class ValueUtf8Coding {

    49 

    50     /**

    51      * Maximum number of bytes of UTF-8 encoded characters in one header value.

    52      * <p>

    53      * There are too many different Unicode code points (more than one million)

    54      * to fit all into one manifest value. The specifications state:

    55      * <q>Implementations should support 65535-byte (not character) header

    56      * values, and 65535 headers per file. They might run out of memory,

    57      * but there should not be hard-coded limits below these values.</q>

    58      *

    59      * @see <a

    60      * href="{@docRoot}/../specs/jar/jar.html#Notes_on_Manifest_and_Signature_Files">

    61      * Notes on Manifest and Signature Files</a>

    62      */

    63     static final int SUPPORTED_VALUE_LENGTH = 65535;

    64 

    65     /**

    66      * Returns {@code true} if {@code codePoint} is known not to be a supported

    67      * character in manifest header values. Explicitly forbidden in manifest

    68      * header values are according to a statement from the specifications:

    69      * <q>otherchar: any UTF-8 character except NUL, CR and LF</q>.

    70      * {@code NUL} ({@code 0x0}), however, works just fine and might have been

    71      * used and might still be.

    72      *

    73      * @see <a href="{@docRoot}/../specs/jar/jar.html#Section-Specification">

    74      * Jar File Specification</a>

    75      */

    76     static boolean isUnsupportedManifestValueCharacter(int codePoint) {

    77         return codePoint == '\r' /* CR */ || codePoint == '\n' /* LF */;

    78     };

    79 

    80     /**

    81      * Produces a list of strings with all Unicode characters except those

    82      * explicitly invalid in manifest header values.

    83      * Each string is filled with as many characters as fit into

    84      * {@link #SUPPORTED_VALUE_LENGTH} bytes with UTF-8 encoding except the

    85      * last string which contains the remaining characters. Each of those

    86      * strings becomes a header value the number of which 65535 should be

    87      * supported per file.

    88      *

    89      * @see <a

    90      * href="{@docRoot}/../specs/jar/jar.html#Notes_on_Manifest_and_Signature_Files">

    91      * Notes on Manifest and Signature Files</a>

    92      */

    93     static List<String> produceValuesWithAllUnicodeCharacters() {

    94         ArrayList<String> values = new ArrayList<>();

    95         byte[] valueBuf = new byte[SUPPORTED_VALUE_LENGTH];

    96         int pos = 0;

    97         for (int codePoint = Character.MIN_CODE_POINT;

    98                 codePoint <= Character.MAX_CODE_POINT; codePoint++) {

    99             if (isUnsupportedManifestValueCharacter(codePoint)) {

   100                 continue;

   101             }

   102 

   103             byte[] charBuf = Character.toString(codePoint).getBytes(UTF_8);

   104             if (pos + charBuf.length > valueBuf.length) {

   105                 values.add(new String(valueBuf, 0, pos, UTF_8));

   106                 pos = 0;

   107             }

   108             System.arraycopy(charBuf, 0, valueBuf, pos, charBuf.length);

   109             pos += charBuf.length;

   110         }

   111         if (pos > 0) {

   112             values.add(new String(valueBuf, 0, pos, UTF_8));

   113         }

   114         // minimum number of headers supported is the same as the minimum size

   115         // of each header value in bytes

   116         assertTrue(values.size() <= SUPPORTED_VALUE_LENGTH);

   117         return values;

   118     }

   119 

   120     /**

   121      * Returns simple, valid, short, and distinct manifest header names.

   122      * The returned name cannot collide with "{@code Manifest-Version}" because

   123      * the returned string does not contain "{@code -}".

   124      */

   125     static Name azName(int seed) {

   126         StringBuffer name = new StringBuffer();

   127         do {

   128             name.insert(0, (char) (seed % 26 + (seed < 26 ? 'A' : 'a')));

   129             seed = seed / 26 - 1;

   130         } while (seed >= 0);

   131         return new Name(name.toString());

   132     }

   133 

   134     /**

   135      * Writes and reads a manifest with the complete Unicode character set.

   136      * The characters are grouped into manifest header values with about as

   137      * many bytes as allowed each, utilizing a single big manifest.

   138      * <p>

   139      * This test assumes that a manifest is encoded and decoded correctly if

   140      * writing and then reading it again results in a manifest with identical

   141      * values as the original. The test is not about other aspects of writing

   142      * and reading manifests than only that, given the fact and the way it

   143      * works for some characters such as the most widely and often used ones,

   144      * it also works for the complete Unicode character set just the same.

   145      * <p>

   146      * Only header values are tested. The set of allowed characters for header

   147      * names are much more limited and are a different topic entirely and most

   148      * simple ones are used here as necessary just to get valid and different

   149      * ones (see {@link #azName}).

   150      * <p>

   151      * Because the current implementation under test uses different portions

   152      * of code depending on where the value occurs to read or write, each

   153      * character is tested in each of the three positions:<ul>

   154      * <li>main attribute header,</li>

   155      * <li>named section name, and</li>

   156      * <li>named sections header values</li>

   157      * </ul>

   158      * Implementation of writing the main section headers in

   159      * {@link Attributes#writeMain(java.io.DataOutputStream)} differs from the

   160      * one writing named section headers in

   161      * {@link Attributes#write(java.io.DataOutputStream)} regarding the special

   162      * order of {@link Name#MANIFEST_VERSION} and

   163      * {@link Name#SIGNATURE_VERSION} and also

   164      * {@link Manifest#read(java.io.InputStream)} at least potentially reads

   165      * main sections differently than reading named sections names headers in

   166      * {@link Attributes#read(Manifest.FastInputStream, byte[])}.

   167      */

   168     @Test

   169     public void testCompleteUnicodeCharacterSet() throws IOException {

   170         Manifest mf = new Manifest();

   171         mf.getMainAttributes().put(Name.MANIFEST_VERSION, "1.0");

   172 

   173         List<String> values = produceValuesWithAllUnicodeCharacters();

   174         for (int i = 0; i < values.size(); i++) {

   175             Name name = azName(i);

   176             String value = values.get(i);

   177 

   178             mf.getMainAttributes().put(name, value);

   179             Attributes attributes = new Attributes();

   180             mf.getEntries().put(value, attributes);

   181             attributes.put(name, value);

   182         }

   183 

   184         mf = writeAndRead(mf);

   185 

   186         for (int i = 0; i < values.size(); i++) {

   187             String value = values.get(i);

   188             Name name = azName(i);

   189 

   190             assertEquals(mf.getMainAttributes().getValue(name), value,

   191                     "main attributes header value");

   192             Attributes attributes = mf.getAttributes(value);

   193             assertNotNull(attributes, "named section");

   194             assertEquals(attributes.getValue(name), value,

   195                     "named section attributes value");

   196         }

   197     }

   198 

   199     static Manifest writeAndRead(Manifest mf) throws IOException {

   200         ByteArrayOutputStream out = new ByteArrayOutputStream();

   201         mf.write(out);

   202         byte[] mfBytes = out.toByteArray();

   203 

   204         System.out.println("-".repeat(72));

   205         System.out.print(new String(mfBytes, UTF_8));

   206         System.out.println("-".repeat(72));

   207 

   208         ByteArrayInputStream in = new ByteArrayInputStream(mfBytes);

   209         return new Manifest(in);

   210     }

   211 

   212 }